/rust/registry/src/index.crates.io-1949cf8c6b5b557f/erased-serde-0.4.10/src/macros.rs

Source
/// Implement `serde::Serialize` for a trait object that has
/// `erased_serde::Serialize` as a supertrait.
///
/// ```
/// use erased_serde::serialize_trait_object;
///
/// trait Event: erased_serde::Serialize {
///     /* ... */
/// }
///
/// erased_serde::serialize_trait_object!(Event);
/// ```
///
/// The macro supports traits that have type parameters and/or `where` clauses.
///
/// ```
/// # use erased_serde::serialize_trait_object;
/// #
/// trait Difficult<T>: erased_serde::Serialize where T: Copy {
///     /* ... */
/// }
///
/// serialize_trait_object!(<T> Difficult<T> where T: Copy);
/// ```
#[macro_export]
macro_rules! serialize_trait_object {
    ($($path:tt)+) => {
        $crate::__internal_serialize_trait_object!(begin $($path)+);
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __internal_serialize_trait_object {
    // Invocation started with `<`, parse generics.
    (begin < $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(generics () () $($rest)*);
    };

    // Invocation did not start with `<`.
    (begin $first:tt $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(path () ($first) $($rest)*);
    };

    // End of generics with trailing comma.
    (generics ($($generics:tt)*) () , > $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*);
    };

    // End of generics without trailing comma.
    (generics ($($generics:tt)*) () > $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*);
    };

    // Generics open bracket.
    (generics ($($generics:tt)*) ($($brackets:tt)*) < $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(generics ($($generics)* <) ($($brackets)* <) $($rest)*);
    };

    // Generics close bracket.
    (generics ($($generics:tt)*) (< $($brackets:tt)*) > $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(generics ($($generics)* >) ($($brackets)*) $($rest)*);
    };

    // Token inside of generics.
    (generics ($($generics:tt)*) ($($brackets:tt)*) $first:tt $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(generics ($($generics)* $first) ($($brackets)*) $($rest)*);
    };

    // End with `where` clause.
    (path ($($generics:tt)*) ($($path:tt)*) where $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ($($rest)*));
    };

    // End without `where` clause.
    (path ($($generics:tt)*) ($($path:tt)*)) => {
        $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ());
    };

    // Token inside of path.
    (path ($($generics:tt)*) ($($path:tt)*) $first:tt $($rest:tt)*) => {
        $crate::__internal_serialize_trait_object!(path ($($generics)*) ($($path)* $first) $($rest)*);
    };

    // Expand into four impls.
    (sendsync ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*)) => {
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)*) ($($bound)*) {
            fn __check_erased_serialize_supertrait<$($generics)* __T>()
            where
                __T: ?$crate::__private::Sized + $($path)*,
                $($bound)*
            {
                $crate::__private::require_erased_serialize_impl::<__T>();
            }
        });
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send) ($($bound)*));
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Sync) ($($bound)*));
        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send + $crate::__private::Sync) ($($bound)*));
    };

    // The impl.
    (impl ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*) $({$($body:tt)*})*) => {
        impl<'erased, $($generics)*> $crate::__private::serde::Serialize for dyn $($path)* + 'erased
        where
            $($bound)*
        {
            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
            where
                S: $crate::__private::serde::Serializer,
            {
                $($($body)*)*
                $crate::serialize(self, serializer)
            }
        }
    };
}

macro_rules! return_impl_trait {
    (
        $(#[$attr:meta])*
        $vis:vis fn $name:ident <$param:ident> $args:tt -> $impl_trait:ty [$concrete:ty] $($body:tt)+
    ) => {
        #[cfg(not(docsrs))]
        $(#[$attr])*
        $vis fn $name <$param> $args -> $concrete $($body)+

        #[cfg(docsrs)]
        $(#[$attr])*
        $vis fn $name <$param> $args -> $impl_trait $($body)+
    };
}

// TEST ////////////////////////////////////////////////////////////////////////

#[cfg(test)]
mod tests {
    use crate::Serialize;

    fn assert_serialize<T: ?Sized + serde::Serialize>() {}

    #[test]
    fn test_plain() {
        trait Trait: Serialize {}

        serialize_trait_object!(Trait);
        assert_serialize::<dyn Trait>();
        assert_serialize::<dyn Trait + Send>();
    }

    #[test]
    fn test_type_parameter() {
        trait Trait<T>: Serialize {}

        serialize_trait_object!(<T> Trait<T>);
        assert_serialize::<dyn Trait<u32>>();
        assert_serialize::<dyn Trait<u32> + Send>();
    }

    #[test]
    fn test_generic_bound() {
        trait Trait<T: PartialEq<T>, U>: Serialize {}

        serialize_trait_object!(<T: PartialEq<T>, U> Trait<T, U>);
        assert_serialize::<dyn Trait<u32, ()>>();
        assert_serialize::<dyn Trait<u32, ()> + Send>();
    }

    #[test]
    fn test_where_clause() {
        trait Trait<T>: Serialize
        where
            T: Clone,
        {
        }

        serialize_trait_object!(<T> Trait<T> where T: Clone);
        assert_serialize::<dyn Trait<u32>>();
        assert_serialize::<dyn Trait<u32> + Send>();
    }
}

Line	Count	Source
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		$($bound)*
92		{
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	0	fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
108	0	where
109	0	S: $crate::__private::serde::Serializer,
110		{
111		$($($body))
112	0	$crate::serialize(self, serializer)
113	0	} Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut dyn sval_dynamic::stream::Stream>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::tag::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::to_f32::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::to_f64::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::to_bool::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::to_i128::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::to_text::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::to_u128::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::stream::Computed<sval::value::default_value::to_binary::Extract>>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::tag::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::to_f32::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::to_f64::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::to_bool::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::to_i128::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::to_text::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::to_u128::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<sval_serde::to_value::Stream<&mut sval::value::default_value::to_binary::Extract>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<serde_fmt::Formatter> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<serde_buf::ser::Serializer> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<value_bag::internal::serde::v1::internal_visit::VisitorSerializer> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde_core::ser::Serialize>::serialize::<_> Unexecuted instantiation: <dyn erased_serde::ser::Serialize + core::marker::Send as serde_core::ser::Serialize>::serialize::<_> Unexecuted instantiation: <dyn erased_serde::ser::Serialize + core::marker::Sync as serde_core::ser::Serialize>::serialize::<_> Unexecuted instantiation: <dyn erased_serde::ser::Serialize + core::marker::Sync + core::marker::Send as serde_core::ser::Serialize>::serialize::<_>
114		}
115		};
116		}
117
118		macro_rules! return_impl_trait {
119		(
120		$(#[$attr:meta])*
121		$vis:vis fn $name:ident <$param:ident> $args:tt -> $impl_trait:ty [$concrete:ty] $($body:tt)+
122		) => {
123		#[cfg(not(docsrs))]
124		$(#[$attr])*
125		$vis fn $name <$param> $args -> $concrete $($body)+
126
127		#[cfg(docsrs)]
128		$(#[$attr])*
129		$vis fn $name <$param> $args -> $impl_trait $($body)+
130		};
131		}
132
133		// TEST ////////////////////////////////////////////////////////////////////////
134
135		#[cfg(test)]
136		mod tests {
137		use crate::Serialize;
138
139		fn assert_serialize<T: ?Sized + serde::Serialize>() {}
140
141		#[test]
142		fn test_plain() {
143		trait Trait: Serialize {}
144
145		serialize_trait_object!(Trait);
146		assert_serialize::<dyn Trait>();
147		assert_serialize::<dyn Trait + Send>();
148		}
149
150		#[test]
151		fn test_type_parameter() {
152		trait Trait<T>: Serialize {}
153
154		serialize_trait_object!(<T> Trait<T>);
155		assert_serialize::<dyn Trait<u32>>();
156		assert_serialize::<dyn Trait<u32> + Send>();
157		}
158
159		#[test]
160		fn test_generic_bound() {
161		trait Trait<T: PartialEq<T>, U>: Serialize {}
162
163		serialize_trait_object!(<T: PartialEq<T>, U> Trait<T, U>);
164		assert_serialize::<dyn Trait<u32, ()>>();
165		assert_serialize::<dyn Trait<u32, ()> + Send>();
166		}
167
168		#[test]
169		fn test_where_clause() {
170		trait Trait<T>: Serialize
171		where
172		T: Clone,
173		{
174		}
175
176		serialize_trait_object!(<T> Trait<T> where T: Clone);
177		assert_serialize::<dyn Trait<u32>>();
178		assert_serialize::<dyn Trait<u32> + Send>();
179		}
180		}

Coverage Report

Created: 2026-06-28 08:04