Skip to content
This repository was archived by the owner on Jun 3, 2025. It is now read-only.

Commit 5da4e62

Browse files
fasterthanlimefasterthanlime
committed
Remove workaround for rust-lang/rust#133676 
1 parent 8520438 commit 5da4e62

File tree

4 files changed

+124
-145
lines changed

4 files changed

+124
-145
lines changed

‎merde_core/src/deserialize.rs

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,9 @@ where
4949
pub trait DynDeserializerExt<'s> {
5050
fn t<'de, T: Deserialize<'s>>(
5151
&'de mut self,
52-
) -> impl Future<Output = Result<T, MerdeError<'s>>> + 'de;
52+
) -> impl Future<Output = Result<T, MerdeError<'s>>> + 'de
53+
where
54+
's: 'de;
5355

5456
fn deserialize<T: Deserialize<'s>>(&mut self) -> Result<T, MerdeError<'s>>;
5557

@@ -60,12 +62,13 @@ impl<'s, D> DynDeserializerExt<'s> for D
6062
where
6163
D: Deserializer<'s>,
6264
{
63-
// cf. <https://github.com/rust-lang/rust/issues/133676>
64-
#[allow(clippy::manual_async_fn)]
6565
fn t<'de, T: Deserialize<'s>>(
6666
&'de mut self,
67-
) -> impl Future<Output = Result<T, MerdeError<'s>>> + 'de {
68-
async move { T::deserialize(self).await }
67+
) -> impl Future<Output = Result<T, MerdeError<'s>>> + 'de
68+
where
69+
's: 'de,
70+
{
71+
T::deserialize(self)
6972
}
7073

7174
fn deserialize<T: Deserialize<'s>>(&mut self) -> Result<T, MerdeError<'s>> {
@@ -80,7 +83,10 @@ where
8083
impl<'s> DynDeserializerExt<'s> for dyn DynDeserializer<'s> + '_ {
8184
fn t<'de, T: Deserialize<'s>>(
8285
&'de mut self,
83-
) -> impl Future<Output = Result<T, MerdeError<'s>>> + 'de {
86+
) -> impl Future<Output = Result<T, MerdeError<'s>>> + 'de
87+
where
88+
's: 'de,
89+
{
8490
T::deserialize(self)
8591
}
8692

‎merde_core/src/lib.rs

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,3 @@
1-
// cf. <https://github.com/rust-lang/rust/issues/133676>
2-
#![allow(clippy::manual_async_fn)]
3-
41
mod cowstr;
52

63
pub use cowstr::CowStr;

‎merde_core/src/serialize.rs

Lines changed: 108 additions & 130 deletions
Original file line numberDiff line numberDiff line change
@@ -91,11 +91,11 @@ macro_rules! impl_trivial_serialize {
9191

9292
($ty:ty) => {
9393
impl Serialize for $ty {
94-
fn serialize<'fut>(
94+
async fn serialize<'fut>(
9595
&'fut self,
9696
serializer: &'fut mut dyn DynSerializer,
97-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'fut {
98-
async { serializer.write(Event::from(*self)).await }
97+
) -> Result<(), MerdeError<'static>> {
98+
serializer.write(Event::from(*self)).await
9999
}
100100
}
101101
};
@@ -115,197 +115,177 @@ impl_trivial_serialize! {
115115
}
116116

117117
impl Serialize for String {
118-
fn serialize<'se>(
118+
async fn serialize<'se>(
119119
&'se self,
120120
serializer: &'se mut dyn DynSerializer,
121-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
122-
async { serializer.write(Event::Str(CowStr::Borrowed(self))).await }
121+
) -> Result<(), MerdeError<'static>> {
122+
serializer.write(Event::Str(CowStr::Borrowed(self))).await
123123
}
124124
}
125125

126126
impl<'s> Serialize for &'s str {
127-
fn serialize<'se>(
127+
async fn serialize<'se>(
128128
&'se self,
129129
serializer: &'se mut dyn DynSerializer,
130-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
131-
async { serializer.write(Event::Str(CowStr::Borrowed(self))).await }
130+
) -> Result<(), MerdeError<'static>> {
131+
serializer.write(Event::Str(CowStr::Borrowed(self))).await
132132
}
133133
}
134134

135135
impl<'s> Serialize for CowStr<'s> {
136-
fn serialize<'se>(
136+
async fn serialize<'se>(
137137
&'se self,
138138
serializer: &'se mut dyn DynSerializer,
139-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
140-
async {
141-
serializer
142-
.write(Event::Str(CowStr::Borrowed(self.as_ref())))
143-
.await
144-
}
139+
) -> Result<(), MerdeError<'static>> {
140+
serializer
141+
.write(Event::Str(CowStr::Borrowed(self.as_ref())))
142+
.await
145143
}
146144
}
147145

148146
impl<'s> Serialize for Cow<'s, str> {
149-
fn serialize<'se>(
147+
async fn serialize<'se>(
150148
&'se self,
151149
serializer: &'se mut dyn DynSerializer,
152-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
153-
async {
154-
serializer
155-
.write(Event::Str(CowStr::Borrowed(self.as_ref())))
156-
.await
157-
}
150+
) -> Result<(), MerdeError<'static>> {
151+
serializer
152+
.write(Event::Str(CowStr::Borrowed(self.as_ref())))
153+
.await
158154
}
159155
}
160156

161157
impl<'s> Serialize for CowBytes<'s> {
162-
fn serialize<'se>(
158+
async fn serialize<'se>(
163159
&'se self,
164160
serializer: &'se mut dyn DynSerializer,
165-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
166-
async {
167-
serializer
168-
.write(Event::Bytes(CowBytes::Borrowed(self.as_ref())))
169-
.await
170-
}
161+
) -> Result<(), MerdeError<'static>> {
162+
serializer
163+
.write(Event::Bytes(CowBytes::Borrowed(self.as_ref())))
164+
.await
171165
}
172166
}
173167

174168
impl<T: Serialize> Serialize for Option<T> {
175-
fn serialize<'se>(
169+
async fn serialize<'se>(
176170
&'se self,
177171
serializer: &'se mut dyn DynSerializer,
178-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
179-
async move {
180-
match self {
181-
Some(value) => value.serialize(serializer).await,
182-
None => serializer.write(Event::Null).await,
183-
}
172+
) -> Result<(), MerdeError<'static>> {
173+
match self {
174+
Some(value) => value.serialize(serializer).await,
175+
None => serializer.write(Event::Null).await,
184176
}
185177
}
186178
}
187179

188180
impl<T: Serialize> Serialize for &[T] {
189-
fn serialize<'se>(
181+
async fn serialize<'se>(
190182
&'se self,
191183
serializer: &'se mut dyn DynSerializer,
192-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
193-
async {
194-
serializer
195-
.write(Event::ArrayStart(ArrayStart {
196-
size_hint: Some(self.len()),
197-
}))
198-
.await?;
199-
for item in *self {
200-
item.serialize(serializer).await?;
201-
}
202-
serializer.write(Event::ArrayEnd).await
184+
) -> Result<(), MerdeError<'static>> {
185+
serializer
186+
.write(Event::ArrayStart(ArrayStart {
187+
size_hint: Some(self.len()),
188+
}))
189+
.await?;
190+
for item in *self {
191+
item.serialize(serializer).await?;
203192
}
193+
serializer.write(Event::ArrayEnd).await
204194
}
205195
}
206196

207197
impl<T: Serialize> Serialize for Vec<T> {
208-
fn serialize<'se>(
198+
async fn serialize<'se>(
209199
&'se self,
210200
serializer: &'se mut dyn DynSerializer,
211-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
212-
async move {
213-
serializer
214-
.write(Event::ArrayStart(ArrayStart {
215-
size_hint: Some(self.len()),
216-
}))
217-
.await?;
218-
for item in self {
219-
item.serialize(serializer).await?;
220-
}
221-
serializer.write(Event::ArrayEnd).await
201+
) -> Result<(), MerdeError<'static>> {
202+
serializer
203+
.write(Event::ArrayStart(ArrayStart {
204+
size_hint: Some(self.len()),
205+
}))
206+
.await?;
207+
for item in self {
208+
item.serialize(serializer).await?;
222209
}
210+
serializer.write(Event::ArrayEnd).await
223211
}
224212
}
225213

226214
impl<K: Serialize, V: Serialize, BH: BuildHasher> Serialize for HashMap<K, V, BH> {
227-
fn serialize<'fut>(
215+
async fn serialize<'fut>(
228216
&'fut self,
229217
serializer: &'fut mut dyn DynSerializer,
230-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'fut {
231-
async move {
232-
serializer
233-
.write(Event::MapStart(MapStart {
234-
size_hint: Some(self.len()),
235-
}))
236-
.await?;
237-
for (key, value) in self {
238-
key.serialize(serializer).await?;
239-
value.serialize(serializer).await?;
240-
}
241-
serializer.write(Event::MapEnd).await
218+
) -> Result<(), MerdeError<'static>> {
219+
serializer
220+
.write(Event::MapStart(MapStart {
221+
size_hint: Some(self.len()),
222+
}))
223+
.await?;
224+
for (key, value) in self {
225+
key.serialize(serializer).await?;
226+
value.serialize(serializer).await?;
242227
}
228+
serializer.write(Event::MapEnd).await
243229
}
244230
}
245231

246232
impl Serialize for Map<'_> {
247-
fn serialize<'se>(
233+
async fn serialize<'se>(
248234
&'se self,
249235
serializer: &'se mut dyn DynSerializer,
250-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
251-
async {
252-
serializer
253-
.write(Event::MapStart(MapStart {
254-
size_hint: Some(self.len()),
255-
}))
256-
.await?;
257-
for (key, value) in self.iter() {
258-
serializer.write(Event::Str(CowStr::Borrowed(key))).await?;
259-
value.serialize(serializer).await?;
260-
}
261-
serializer.write(Event::MapEnd).await
236+
) -> Result<(), MerdeError<'static>> {
237+
serializer
238+
.write(Event::MapStart(MapStart {
239+
size_hint: Some(self.len()),
240+
}))
241+
.await?;
242+
for (key, value) in self.iter() {
243+
serializer.write(Event::Str(CowStr::Borrowed(key))).await?;
244+
value.serialize(serializer).await?;
262245
}
246+
serializer.write(Event::MapEnd).await
263247
}
264248
}
265249

266250
impl Serialize for Array<'_> {
267-
fn serialize<'se>(
251+
async fn serialize<'se>(
268252
&'se self,
269253
serializer: &'se mut dyn DynSerializer,
270-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
271-
async {
272-
serializer
273-
.write(Event::ArrayStart(ArrayStart {
274-
size_hint: Some(self.len()),
275-
}))
276-
.await?;
277-
for item in self.iter() {
278-
item.serialize(serializer).await?;
279-
}
280-
serializer.write(Event::ArrayEnd).await
254+
) -> Result<(), MerdeError<'static>> {
255+
serializer
256+
.write(Event::ArrayStart(ArrayStart {
257+
size_hint: Some(self.len()),
258+
}))
259+
.await?;
260+
for item in self.iter() {
261+
item.serialize(serializer).await?;
281262
}
263+
serializer.write(Event::ArrayEnd).await
282264
}
283265
}
284266

285267
impl Serialize for Value<'_> {
286-
fn serialize<'se>(
268+
async fn serialize<'se>(
287269
&'se self,
288270
serializer: &'se mut dyn DynSerializer,
289-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
290-
async move {
291-
match self {
292-
Value::I64(i) => serializer.write(Event::I64(*i)).await,
293-
Value::U64(u) => serializer.write(Event::U64(*u)).await,
294-
Value::Float(f) => serializer.write(Event::F64(f.into_inner())).await,
295-
Value::Str(s) => serializer.write(Event::Str(s.clone())).await,
296-
Value::Bytes(b) => serializer.write(Event::Bytes(b.clone())).await,
297-
Value::Null => serializer.write(Event::Null).await,
298-
Value::Bool(b) => serializer.write(Event::Bool(*b)).await,
299-
Value::Array(arr) => {
300-
arr.serialize(serializer)
301-
.with_metastack_resume_point()
302-
.await
303-
}
304-
Value::Map(map) => {
305-
map.serialize(serializer)
306-
.with_metastack_resume_point()
307-
.await
308-
}
271+
) -> Result<(), MerdeError<'static>> {
272+
match self {
273+
Value::I64(i) => serializer.write(Event::I64(*i)).await,
274+
Value::U64(u) => serializer.write(Event::U64(*u)).await,
275+
Value::Float(f) => serializer.write(Event::F64(f.into_inner())).await,
276+
Value::Str(s) => serializer.write(Event::Str(s.clone())).await,
277+
Value::Bytes(b) => serializer.write(Event::Bytes(b.clone())).await,
278+
Value::Null => serializer.write(Event::Null).await,
279+
Value::Bool(b) => serializer.write(Event::Bool(*b)).await,
280+
Value::Array(arr) => {
281+
arr.serialize(serializer)
282+
.with_metastack_resume_point()
283+
.await
284+
}
285+
Value::Map(map) => {
286+
map.serialize(serializer)
287+
.with_metastack_resume_point()
288+
.await
309289
}
310290
}
311291
}
@@ -314,18 +294,16 @@ impl Serialize for Value<'_> {
314294
macro_rules! impl_serialize_for_tuple {
315295
($($type_arg:ident),*) => {
316296
impl<$($type_arg: Serialize),*> Serialize for ($($type_arg),*,) {
317-
fn serialize<'se>(
297+
async fn serialize<'se>(
318298
&'se self,
319299
serializer: &'se mut dyn DynSerializer,
320-
) -> impl Future<Output = Result<(), MerdeError<'static>>> + 'se {
321-
async move {
322-
serializer.write(Event::ArrayStart(ArrayStart {
323-
size_hint: Some(count_tup!($($type_arg)*))
324-
})).await?;
325-
326-
impl_serialize_for_tuple!(@inner self serializer _field => _field () ($($type_arg)*));
327-
serializer.write(Event::ArrayEnd).await
328-
}
300+
) -> Result<(), MerdeError<'static>> {
301+
serializer.write(Event::ArrayStart(ArrayStart {
302+
size_hint: Some(count_tup!($($type_arg)*))
303+
})).await?;
304+
305+
impl_serialize_for_tuple!(@inner self serializer _field => _field () ($($type_arg)*));
306+
serializer.write(Event::ArrayEnd).await
329307
}
330308
}
331309
};

0 commit comments

Comments
 (0)