/rust/registry/src/index.crates.io-6f17d22bba15001f/erased-serde-0.3.31/src/macros.rs

Source (jump to first uncovered line)
/// 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)
            }
        }
    };
}

// 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 (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	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	0	{
111	0	$($($body))
112	0	$crate::serialize(self, serializer)
113	0	} Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde_json::ser::MapKeySerializer<&mut alloc::vec::Vec<u8>, serde_json::ser::CompactFormatter>> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde_json::value::ser::Serializer> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<serde_json::value::ser::MapKeySerializer> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<&mut dyn erased_serde::ser::Serializer> Unexecuted instantiation: <dyn erased_serde::ser::Serialize as serde::ser::Serialize>::serialize::<&mut serde_json::ser::Serializer<&mut alloc::vec::Vec<u8>>> 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::Send + core::marker::Sync 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		}

Coverage Report

Created: 2024-07-06 06:44