proc_macro/bridge/
rpc.rs

Help
1//! Serialization for client-server communication.
2
3use std::any::Any;
4use std::io::Write;
5use std::num::NonZero;
6use std::str;
7
8pub(super) type Writer = super::buffer::Buffer;
9
10pub(super) trait Encode<S>: Sized {
11    fn encode(self, w: &mut Writer, s: &mut S);
12}
13
14pub(super) type Reader<'a> = &'a [u8];
15
16pub(super) trait Decode<'a, 's, S>: Sized {
17    fn decode(r: &mut Reader<'a>, s: &'s S) -> Self;
18}
19
20pub(super) trait DecodeMut<'a, 's, S>: Sized {
21    fn decode(r: &mut Reader<'a>, s: &'s mut S) -> Self;
22}
23
24macro_rules! rpc_encode_decode {
25    (le $ty:ty) => {
26        impl<S> Encode<S> for $ty {
27            fn encode(self, w: &mut Writer, _: &mut S) {
28                w.extend_from_array(&self.to_le_bytes());
29            }
30        }
31
32        impl<S> DecodeMut<'_, '_, S> for $ty {
33            fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
34                const N: usize = ::std::mem::size_of::<$ty>();
35
36                let mut bytes = [0; N];
37                bytes.copy_from_slice(&r[..N]);
38                *r = &r[N..];
39
40                Self::from_le_bytes(bytes)
41            }
42        }
43    };
44    (struct $name:ident $(<$($T:ident),+>)? { $($field:ident),* $(,)? }) => {
45        impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
46            fn encode(self, w: &mut Writer, s: &mut S) {
47                $(self.$field.encode(w, s);)*
48            }
49        }
50
51        impl<'a, S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)?> DecodeMut<'a, '_, S>
52            for $name $(<$($T),+>)?
53        {
54            fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
55                $name {
56                    $($field: DecodeMut::decode(r, s)),*
57                }
58            }
59        }
60    };
61    (enum $name:ident $(<$($T:ident),+>)? { $($variant:ident $(($field:ident))*),* $(,)? }) => {
62        impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
63            fn encode(self, w: &mut Writer, s: &mut S) {
64                // HACK(eddyb): `Tag` enum duplicated between the
65                // two impls as there's no other place to stash it.
66                #[allow(non_upper_case_globals)]
67                mod tag {
68                    #[repr(u8)] enum Tag { $($variant),* }
69
70                    $(pub(crate) const $variant: u8 = Tag::$variant as u8;)*
71                }
72
73                match self {
74                    $($name::$variant $(($field))* => {
75                        tag::$variant.encode(w, s);
76                        $($field.encode(w, s);)*
77                    })*
78                }
79            }
80        }
81
82        impl<'a, S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)?> DecodeMut<'a, '_, S>
83            for $name $(<$($T),+>)?
84        {
85            fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
86                // HACK(eddyb): `Tag` enum duplicated between the
87                // two impls as there's no other place to stash it.
88                #[allow(non_upper_case_globals)]
89                mod tag {
90                    #[repr(u8)] enum Tag { $($variant),* }
91
92                    $(pub(crate) const $variant: u8 = Tag::$variant as u8;)*
93                }
94
95                match u8::decode(r, s) {
96                    $(tag::$variant => {
97                        $(let $field = DecodeMut::decode(r, s);)*
98                        $name::$variant $(($field))*
99                    })*
100                    _ => unreachable!(),
101                }
102            }
103        }
104    }
105}
106
107impl<S> Encode<S> for () {
108    fn encode(self, _: &mut Writer, _: &mut S) {}
109}
110
111impl<S> DecodeMut<'_, '_, S> for () {
112    fn decode(_: &mut Reader<'_>, _: &mut S) -> Self {}
113}
114
115impl<S> Encode<S> for u8 {
116    fn encode(self, w: &mut Writer, _: &mut S) {
117        w.push(self);
118    }
119}
120
121impl<S> DecodeMut<'_, '_, S> for u8 {
122    fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
123        let x = r[0];
124        *r = &r[1..];
125        x
126    }
127}
128
129rpc_encode_decode!(le u32);
130rpc_encode_decode!(le usize);
131
132impl<S> Encode<S> for bool {
133    fn encode(self, w: &mut Writer, s: &mut S) {
134        (self as u8).encode(w, s);
135    }
136}
137
138impl<S> DecodeMut<'_, '_, S> for bool {
139    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
140        match u8::decode(r, s) {
141            0 => false,
142            1 => true,
143            _ => unreachable!(),
144        }
145    }
146}
147
148impl<S> Encode<S> for char {
149    fn encode(self, w: &mut Writer, s: &mut S) {
150        (self as u32).encode(w, s);
151    }
152}
153
154impl<S> DecodeMut<'_, '_, S> for char {
155    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
156        char::from_u32(u32::decode(r, s)).unwrap()
157    }
158}
159
160impl<S> Encode<S> for NonZero<u32> {
161    fn encode(self, w: &mut Writer, s: &mut S) {
162        self.get().encode(w, s);
163    }
164}
165
166impl<S> DecodeMut<'_, '_, S> for NonZero<u32> {
167    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
168        Self::new(u32::decode(r, s)).unwrap()
169    }
170}
171
172impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {
173    fn encode(self, w: &mut Writer, s: &mut S) {
174        self.0.encode(w, s);
175        self.1.encode(w, s);
176    }
177}
178
179impl<'a, S, A: for<'s> DecodeMut<'a, 's, S>, B: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S>
180    for (A, B)
181{
182    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
183        (DecodeMut::decode(r, s), DecodeMut::decode(r, s))
184    }
185}
186
187impl<S> Encode<S> for &[u8] {
188    fn encode(self, w: &mut Writer, s: &mut S) {
189        self.len().encode(w, s);
190        w.write_all(self).unwrap();
191    }
192}
193
194impl<'a, S> DecodeMut<'a, '_, S> for &'a [u8] {
195    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
196        let len = usize::decode(r, s);
197        let xs = &r[..len];
198        *r = &r[len..];
199        xs
200    }
201}
202
203impl<S> Encode<S> for &str {
204    fn encode(self, w: &mut Writer, s: &mut S) {
205        self.as_bytes().encode(w, s);
206    }
207}
208
209impl<'a, S> DecodeMut<'a, '_, S> for &'a str {
210    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
211        str::from_utf8(<&[u8]>::decode(r, s)).unwrap()
212    }
213}
214
215impl<S> Encode<S> for String {
216    fn encode(self, w: &mut Writer, s: &mut S) {
217        self[..].encode(w, s);
218    }
219}
220
221impl<S> DecodeMut<'_, '_, S> for String {
222    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
223        <&str>::decode(r, s).to_string()
224    }
225}
226
227impl<S, T: Encode<S>> Encode<S> for Vec<T> {
228    fn encode(self, w: &mut Writer, s: &mut S) {
229        self.len().encode(w, s);
230        for x in self {
231            x.encode(w, s);
232        }
233    }
234}
235
236impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec<T> {
237    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
238        let len = usize::decode(r, s);
239        let mut vec = Vec::with_capacity(len);
240        for _ in 0..len {
241            vec.push(T::decode(r, s));
242        }
243        vec
244    }
245}
246
247/// Simplified version of panic payloads, ignoring
248/// types other than `&'static str` and `String`.
249pub enum PanicMessage {
250    StaticStr(&'static str),
251    String(String),
252    Unknown,
253}
254
255impl From<Box<dyn Any + Send>> for PanicMessage {
256    fn from(payload: Box<dyn Any + Send + 'static>) -> Self {
257        if let Some(s) = payload.downcast_ref::<&'static str>() {
258            return PanicMessage::StaticStr(s);
259        }
260        if let Ok(s) = payload.downcast::<String>() {
261            return PanicMessage::String(*s);
262        }
263        PanicMessage::Unknown
264    }
265}
266
267impl From<PanicMessage> for Box<dyn Any + Send> {
268    fn from(val: PanicMessage) -> Self {
269        match val {
270            PanicMessage::StaticStr(s) => Box::new(s),
271            PanicMessage::String(s) => Box::new(s),
272            PanicMessage::Unknown => {
273                struct UnknownPanicMessage;
274                Box::new(UnknownPanicMessage)
275            }
276        }
277    }
278}
279
280impl PanicMessage {
281    pub fn as_str(&self) -> Option<&str> {
282        match self {
283            PanicMessage::StaticStr(s) => Some(s),
284            PanicMessage::String(s) => Some(s),
285            PanicMessage::Unknown => None,
286        }
287    }
288}
289
290impl<S> Encode<S> for PanicMessage {
291    fn encode(self, w: &mut Writer, s: &mut S) {
292        self.as_str().encode(w, s);
293    }
294}
295
296impl<S> DecodeMut<'_, '_, S> for PanicMessage {
297    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
298        match Option::<String>::decode(r, s) {
299            Some(s) => PanicMessage::String(s),
300            None => PanicMessage::Unknown,
301        }
302    }
303}
proc_macro/bridge/rpc.rs

proc_macro/bridge/
rpc.rs
