Coverage Report

Created: 2025-06-24 06:14

/rust/registry/src/index.crates.io-6f17d22bba15001f/erased-serde-0.4.6/src/macros.rs
Line
Count
Source (jump to first uncovered line)
1
/// Implement `serde::Serialize` for a trait object that has
2
/// `erased_serde::Serialize` as a supertrait.
3
///
4
/// ```
5
/// use erased_serde::serialize_trait_object;
6
///
7
/// trait Event: erased_serde::Serialize {
8
///     /* ... */
9
/// }
10
///
11
/// erased_serde::serialize_trait_object!(Event);
12
/// ```
13
///
14
/// The macro supports traits that have type parameters and/or `where` clauses.
15
///
16
/// ```
17
/// # use erased_serde::serialize_trait_object;
18
/// #
19
/// trait Difficult<T>: erased_serde::Serialize where T: Copy {
20
///     /* ... */
21
/// }
22
///
23
/// serialize_trait_object!(<T> Difficult<T> where T: Copy);
24
/// ```
25
#[macro_export]
26
macro_rules! serialize_trait_object {
27
    ($($path:tt)+) => {
28
        $crate::__internal_serialize_trait_object!(begin $($path)+);
29
    };
30
}
31
32
#[doc(hidden)]
33
#[macro_export]
34
macro_rules! __internal_serialize_trait_object {
35
    // Invocation started with `<`, parse generics.
36
    (begin < $($rest:tt)*) => {
37
        $crate::__internal_serialize_trait_object!(generics () () $($rest)*);
38
    };
39
40
    // Invocation did not start with `<`.
41
    (begin $first:tt $($rest:tt)*) => {
42
        $crate::__internal_serialize_trait_object!(path () ($first) $($rest)*);
43
    };
44
45
    // End of generics with trailing comma.
46
    (generics ($($generics:tt)*) () , > $($rest:tt)*) => {
47
        $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*);
48
    };
49
50
    // End of generics without trailing comma.
51
    (generics ($($generics:tt)*) () > $($rest:tt)*) => {
52
        $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*);
53
    };
54
55
    // Generics open bracket.
56
    (generics ($($generics:tt)*) ($($brackets:tt)*) < $($rest:tt)*) => {
57
        $crate::__internal_serialize_trait_object!(generics ($($generics)* <) ($($brackets)* <) $($rest)*);
58
    };
59
60
    // Generics close bracket.
61
    (generics ($($generics:tt)*) (< $($brackets:tt)*) > $($rest:tt)*) => {
62
        $crate::__internal_serialize_trait_object!(generics ($($generics)* >) ($($brackets)*) $($rest)*);
63
    };
64
65
    // Token inside of generics.
66
    (generics ($($generics:tt)*) ($($brackets:tt)*) $first:tt $($rest:tt)*) => {
67
        $crate::__internal_serialize_trait_object!(generics ($($generics)* $first) ($($brackets)*) $($rest)*);
68
    };
69
70
    // End with `where` clause.
71
    (path ($($generics:tt)*) ($($path:tt)*) where $($rest:tt)*) => {
72
        $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ($($rest)*));
73
    };
74
75
    // End without `where` clause.
76
    (path ($($generics:tt)*) ($($path:tt)*)) => {
77
        $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ());
78
    };
79
80
    // Token inside of path.
81
    (path ($($generics:tt)*) ($($path:tt)*) $first:tt $($rest:tt)*) => {
82
        $crate::__internal_serialize_trait_object!(path ($($generics)*) ($($path)* $first) $($rest)*);
83
    };
84
85
    // Expand into four impls.
86
    (sendsync ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*)) => {
87
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)*) ($($bound)*) {
88
0
            fn __check_erased_serialize_supertrait<$($generics)* __T>()
89
0
            where
90
0
                __T: ?$crate::__private::Sized + $($path)*,
91
0
                $($bound)*
92
0
            {
93
0
                $crate::__private::require_erased_serialize_impl::<__T>();
94
0
            }
95
        });
96
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send) ($($bound)*));
97
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Sync) ($($bound)*));
98
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send + $crate::__private::Sync) ($($bound)*));
99
    };
100
101
    // The impl.
102
    (impl ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*) $({$($body:tt)*})*) => {
103
        impl<'erased, $($generics)*> $crate::__private::serde::Serialize for dyn $($path)* + 'erased
104
        where
105
            $($bound)*
106
        {
107
76.6M
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
76.6M
            where
109
76.6M
                S: $crate::__private::serde::Serializer,
110
76.6M
            {
111
76.6M
                $($($body)*)*
112
76.6M
                $crate::serialize(self, serializer)
113
76.6M
            }
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<erased_serde::ser::MakeSerializer<&mut dyn erased_serde::ser::Serializer>>
Line
Count
Source
107
2.76M
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
2.76M
            where
109
2.76M
                S: $crate::__private::serde::Serializer,
110
2.76M
            {
111
2.76M
                $($($body)*)*
112
2.76M
                $crate::serialize(self, serializer)
113
2.76M
            }
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::TaggedSerializer<erased_serde::ser::MakeSerializer<&mut dyn erased_serde::ser::Serializer>>>
Line
Count
Source
107
227k
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
227k
            where
109
227k
                S: $crate::__private::serde::Serializer,
110
227k
            {
111
227k
                $($($body)*)*
112
227k
                $crate::serialize(self, serializer)
113
227k
            }
Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::TaggedSerializer<ron::ser::raw::Serializer<&mut alloc::string::String>>>
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::TaggedSerializer<&mut ron::ser::Serializer<&mut alloc::string::String>>>
Line
Count
Source
107
168k
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
168k
            where
109
168k
                S: $crate::__private::serde::Serializer,
110
168k
            {
111
168k
                $($($body)*)*
112
168k
                $crate::serialize(self, serializer)
113
168k
            }
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::FlatMapSerializer<<arbitrary::typed_data::BorrowedTypedSerdeData as serde::ser::Serialize>::serialize::FlatMapKeyConflictDetector<erased_serde::ser::MakeSerializer<&mut dyn erased_serde::ser::SerializeMap>>>>
Line
Count
Source
107
141k
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
141k
            where
109
141k
                S: $crate::__private::serde::Serializer,
110
141k
            {
111
141k
                $($($body)*)*
112
141k
                $crate::serialize(self, serializer)
113
141k
            }
Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::FlatMapSerializer<<arbitrary::typed_data::BorrowedTypedSerdeData as serde::ser::Serialize>::serialize::FlatMapKeyConflictDetector<serde::ser::impossible::Impossible<(), ron::error::Error>>>>
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::FlatMapSerializer<<arbitrary::typed_data::BorrowedTypedSerdeData as serde::ser::Serialize>::serialize::FlatMapKeyConflictDetector<ron::ser::Compound<&mut alloc::string::String>>>>
Line
Count
Source
107
153k
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
153k
            where
109
153k
                S: $crate::__private::serde::Serializer,
110
153k
            {
111
153k
                $($($body)*)*
112
153k
                $crate::serialize(self, serializer)
113
153k
            }
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::FlatMapSerializer<<arbitrary::typed_data::BorrowedTypedSerdeData as serde::ser::Serialize>::serialize::FlatMapKeyConflictDetector<erased_serde::ser::MakeSerializer<&mut dyn erased_serde::ser::SerializeMap>>>>
Line
Count
Source
107
381k
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
381k
            where
109
381k
                S: $crate::__private::serde::Serializer,
110
381k
            {
111
381k
                $($($body)*)*
112
381k
                $crate::serialize(self, serializer)
113
381k
            }
Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::FlatMapSerializer<<arbitrary::typed_data::BorrowedTypedSerdeData as serde::ser::Serialize>::serialize::FlatMapKeyConflictDetector<serde::ser::impossible::Impossible<(), ron::error::Error>>>>
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::FlatMapSerializer<<arbitrary::typed_data::BorrowedTypedSerdeData as serde::ser::Serialize>::serialize::FlatMapKeyConflictDetector<ron::ser::Compound<&mut alloc::string::String>>>>
Line
Count
Source
107
411k
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
411k
            where
109
411k
                S: $crate::__private::serde::Serializer,
110
411k
            {
111
411k
                $($($body)*)*
112
411k
                $crate::serialize(self, serializer)
113
411k
            }
Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<ron::ser::raw::Serializer<&mut alloc::string::String>>
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::content::ContentSerializer<erased_serde::ser::ErrorImpl>>
Line
Count
Source
107
28.5M
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
28.5M
            where
109
28.5M
                S: $crate::__private::serde::Serializer,
110
28.5M
            {
111
28.5M
                $($($body)*)*
112
28.5M
                $crate::serialize(self, serializer)
113
28.5M
            }
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde::__private::ser::content::ContentSerializer<ron::error::Error>>
Line
Count
Source
107
16.4M
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
16.4M
            where
109
16.4M
                S: $crate::__private::serde::Serializer,
110
16.4M
            {
111
16.4M
                $($($body)*)*
112
16.4M
                $crate::serialize(self, serializer)
113
16.4M
            }
<dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<&mut ron::ser::Serializer<&mut alloc::string::String>>
Line
Count
Source
107
27.4M
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108
27.4M
            where
109
27.4M
                S: $crate::__private::serde::Serializer,
110
27.4M
            {
111
27.4M
                $($($body)*)*
112
27.4M
                $crate::serialize(self, serializer)
113
27.4M
            }
Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<_>
Unexecuted instantiation: <dyn erased_serde::ser::Serialize + core::marker::Send as serde::ser::Serialize>::serialize::<_>
Unexecuted instantiation: <dyn erased_serde::ser::Serialize + core::marker::Sync as serde::ser::Serialize>::serialize::<_>
Unexecuted instantiation: <dyn erased_serde::ser::Serialize + core::marker::Sync + core::marker::Send as serde::ser::Serialize>::serialize::<_>
114
        }
115
    };
116
}
117
118
// TEST ////////////////////////////////////////////////////////////////////////
119
120
#[cfg(test)]
121
mod tests {
122
    use crate::Serialize;
123
124
    fn assert_serialize<T: ?Sized + serde::Serialize>() {}
125
126
    #[test]
127
    fn test_plain() {
128
        trait Trait: Serialize {}
129
130
        serialize_trait_object!(Trait);
131
        assert_serialize::<dyn Trait>();
132
        assert_serialize::<dyn Trait + Send>();
133
    }
134
135
    #[test]
136
    fn test_type_parameter() {
137
        trait Trait<T>: Serialize {}
138
139
        serialize_trait_object!(<T> Trait<T>);
140
        assert_serialize::<dyn Trait<u32>>();
141
        assert_serialize::<dyn Trait<u32> + Send>();
142
    }
143
144
    #[test]
145
    fn test_generic_bound() {
146
        trait Trait<T: PartialEq<T>, U>: Serialize {}
147
148
        serialize_trait_object!(<T: PartialEq<T>, U> Trait<T, U>);
149
        assert_serialize::<dyn Trait<u32, ()>>();
150
        assert_serialize::<dyn Trait<u32, ()> + Send>();
151
    }
152
153
    #[test]
154
    fn test_where_clause() {
155
        trait Trait<T>: Serialize
156
        where
157
            T: Clone,
158
        {
159
        }
160
161
        serialize_trait_object!(<T> Trait<T> where T: Clone);
162
        assert_serialize::<dyn Trait<u32>>();
163
        assert_serialize::<dyn Trait<u32> + Send>();
164
    }
165
}