feat(rspack_cacheable): as attr support use with dyn trait (#8535)

jerrykingxyz · web-flow · commit c1e8f1122ece · 2024-11-26T17:28:55.000+08:00
* feat(rspack_cacheable): `as` attr support use with dyn trait

* fix: ci
diff --git a/crates/rspack_cacheable/src/context.rs b/crates/rspack_cacheable/src/context.rs
@@ -20,15 +20,15 @@ impl<'a> ContextGuard<'a> {
     Self { context }
   }
 
-  pub fn add_to_sharing<S: Sharing<SerializeError>>(
+  pub fn add_to_sharing<S: Sharing<SerializeError> + ?Sized>(
     &self,
     sharing: &mut S,
   ) -> Result<(), SerializeError> {
     sharing.start_sharing(CONTEXT_ADDR);
     sharing.finish_sharing(CONTEXT_ADDR, self as *const _ as usize)
   }
 
-  pub fn sharing_context<S: Sharing<SerializeError>>(
+  pub fn sharing_context<S: Sharing<SerializeError> + ?Sized>(
     sharing: &'a mut S,
   ) -> Result<&'a dyn Any, SerializeError> {
     match sharing.start_sharing(CONTEXT_ADDR) {
@@ -40,7 +40,7 @@ impl<'a> ContextGuard<'a> {
     }
   }
 
-  pub fn add_to_pooling<P: Pooling<DeserializeError>>(
+  pub fn add_to_pooling<P: Pooling<DeserializeError> + ?Sized>(
     &self,
     pooling: &mut P,
   ) -> Result<(), DeserializeError> {
@@ -51,7 +51,7 @@ impl<'a> ContextGuard<'a> {
     }
   }
 
-  pub fn pooling_context<P: Pooling<DeserializeError>>(
+  pub fn pooling_context<P: Pooling<DeserializeError> + ?Sized>(
     pooling: &'a mut P,
   ) -> Result<&'a dyn Any, DeserializeError> {
     match pooling.start_pooling(CONTEXT_ADDR) {
diff --git a/crates/rspack_cacheable/src/with/as.rs b/crates/rspack_cacheable/src/with/as.rs
@@ -43,7 +43,7 @@ where
 impl<T, A, S> SerializeWith<T, S> for As<A>
 where
   A: AsConverter<T> + Archive + Serialize<S>,
-  S: Fallible<Error = SerializeError> + Sharing,
+  S: Fallible<Error = SerializeError> + Sharing + ?Sized,
 {
   #[inline]
   fn serialize_with(field: &T, serializer: &mut S) -> Result<Self::Resolver, SerializeError> {
@@ -60,7 +60,7 @@ impl<T, A, D> DeserializeWith<Archived<A>, T, D> for As<A>
 where
   A: AsConverter<T> + Archive,
   A::Archived: Deserialize<A, D>,
-  D: Fallible<Error = DeserializeError> + Pooling,
+  D: Fallible<Error = DeserializeError> + Pooling + ?Sized,
 {
   #[inline]
   fn deserialize_with(field: &Archived<A>, de: &mut D) -> Result<T, DeserializeError> {
diff --git a/crates/rspack_cacheable/src/with/as_cacheable.rs b/crates/rspack_cacheable/src/with/as_cacheable.rs
@@ -20,7 +20,7 @@ impl<T: Archive> ArchiveWith<T> for AsCacheable {
 impl<T, S> SerializeWith<T, S> for AsCacheable
 where
   T: Archive + Serialize<S>,
-  S: ?Sized + Fallible,
+  S: Fallible + ?Sized,
 {
   #[inline]
   fn serialize_with(field: &T, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
@@ -32,7 +32,7 @@ impl<T, D> DeserializeWith<Archived<T>, T, D> for AsCacheable
 where
   T: Archive,
   T::Archived: Deserialize<T, D>,
-  D: ?Sized + Fallible,
+  D: Fallible + ?Sized,
 {
   #[inline]
   fn deserialize_with(field: &Archived<T>, de: &mut D) -> Result<T, D::Error> {
diff --git a/crates/rspack_cacheable/src/with/as_inner.rs b/crates/rspack_cacheable/src/with/as_inner.rs
@@ -48,7 +48,7 @@ impl<T, A, O, D> DeserializeWith<A::Archived, T, D> for AsInner<A>
 where
   T: AsInnerConverter<Inner = O>,
   A: ArchiveWith<O> + DeserializeWith<A::Archived, O, D>,
-  D: ?Sized + Fallible,
+  D: Fallible + ?Sized,
 {
   fn deserialize_with(field: &A::Archived, d: &mut D) -> Result<T, D::Error> {
     Ok(T::from_inner(A::deserialize_with(field, d)?))
diff --git a/crates/rspack_cacheable/src/with/as_map.rs b/crates/rspack_cacheable/src/with/as_map.rs
@@ -57,10 +57,11 @@ where
   }
 }
 
-impl<WK, WV, K, V, S: Fallible + ?Sized> Serialize<S> for Entry<&'_ K, &'_ V, WK, WV>
+impl<WK, WV, K, V, S> Serialize<S> for Entry<&'_ K, &'_ V, WK, WV>
 where
   WK: SerializeWith<K, S>,
   WV: SerializeWith<V, S>,
+  S: Fallible + ?Sized,
 {
   #[inline]
   fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
@@ -90,7 +91,7 @@ where
   T: AsMapConverter<Key = K, Value = V>,
   WK: ArchiveWith<K>,
   WV: ArchiveWith<V>,
-  S: Fallible + ?Sized + Allocator + Writer,
+  S: Fallible + Allocator + Writer + ?Sized,
   for<'a> Entry<&'a K, &'a V, WK, WV>: Serialize<S>,
 {
   fn serialize_with(field: &T, s: &mut S) -> Result<Self::Resolver, S::Error> {
diff --git a/crates/rspack_cacheable/src/with/as_ref_str.rs b/crates/rspack_cacheable/src/with/as_ref_str.rs
@@ -31,7 +31,7 @@ where
 impl<T, S> SerializeWith<T, S> for AsRefStr
 where
   T: AsRefStrConverter,
-  S: ?Sized + Fallible + Writer,
+  S: Fallible + Writer + ?Sized,
   S::Error: Source,
 {
   #[inline]
@@ -43,7 +43,7 @@ where
 impl<T, D> DeserializeWith<ArchivedString, T, D> for AsRefStr
 where
   T: AsRefStrConverter,
-  D: ?Sized + Fallible,
+  D: Fallible + ?Sized,
 {
   #[inline]
   fn deserialize_with(field: &ArchivedString, _: &mut D) -> Result<T, D::Error> {
diff --git a/crates/rspack_cacheable/src/with/as_string.rs b/crates/rspack_cacheable/src/with/as_string.rs
@@ -39,7 +39,7 @@ where
 impl<T, S> SerializeWith<T, S> for AsString
 where
   T: AsStringConverter,
-  S: Fallible<Error = SerializeError> + Writer,
+  S: Fallible<Error = SerializeError> + Writer + ?Sized,
 {
   #[inline]
   fn serialize_with(field: &T, serializer: &mut S) -> Result<Self::Resolver, SerializeError> {
@@ -52,7 +52,7 @@ where
 impl<T, D> DeserializeWith<ArchivedString, T, D> for AsString
 where
   T: AsStringConverter,
-  D: Fallible<Error = DeserializeError>,
+  D: Fallible<Error = DeserializeError> + ?Sized,
 {
   #[inline]
   fn deserialize_with(field: &ArchivedString, _: &mut D) -> Result<T, DeserializeError> {
diff --git a/crates/rspack_cacheable/src/with/as_tuple2.rs b/crates/rspack_cacheable/src/with/as_tuple2.rs
@@ -30,10 +30,11 @@ where
   }
 }
 
-impl<A, B, K, V, S: Fallible + ?Sized> SerializeWith<(K, V), S> for AsTuple2<A, B>
+impl<A, B, K, V, S> SerializeWith<(K, V), S> for AsTuple2<A, B>
 where
   A: SerializeWith<K, S>,
   B: SerializeWith<V, S>,
+  S: Fallible + ?Sized,
 {
   #[inline]
   fn serialize_with(field: &(K, V), serializer: &mut S) -> Result<Self::Resolver, S::Error> {
@@ -49,7 +50,7 @@ impl<A, B, K, V, D> DeserializeWith<ArchivedTuple2<A::Archived, B::Archived>, (K
 where
   A: ArchiveWith<K> + DeserializeWith<A::Archived, K, D>,
   B: ArchiveWith<V> + DeserializeWith<B::Archived, V, D>,
-  D: ?Sized + Fallible,
+  D: Fallible + ?Sized,
 {
   fn deserialize_with(
     field: &ArchivedTuple2<A::Archived, B::Archived>,
diff --git a/crates/rspack_cacheable/src/with/as_tuple3.rs b/crates/rspack_cacheable/src/with/as_tuple3.rs
@@ -34,11 +34,12 @@ where
   }
 }
 
-impl<A, B, C, K, V, H, S: Fallible + ?Sized> SerializeWith<(K, V, H), S> for AsTuple3<A, B, C>
+impl<A, B, C, K, V, H, S> SerializeWith<(K, V, H), S> for AsTuple3<A, B, C>
 where
   A: SerializeWith<K, S>,
   B: SerializeWith<V, S>,
   C: SerializeWith<H, S>,
+  S: Fallible + ?Sized,
 {
   #[inline]
   fn serialize_with(field: &(K, V, H), serializer: &mut S) -> Result<Self::Resolver, S::Error> {
@@ -57,7 +58,7 @@ where
   A: ArchiveWith<K> + DeserializeWith<A::Archived, K, D>,
   B: ArchiveWith<V> + DeserializeWith<B::Archived, V, D>,
   C: ArchiveWith<H> + DeserializeWith<C::Archived, H, D>,
-  D: ?Sized + Fallible,
+  D: Fallible + ?Sized,
 {
   fn deserialize_with(
     field: &ArchivedTuple3<A::Archived, B::Archived, C::Archived>,
diff --git a/crates/rspack_cacheable/src/with/as_vec.rs b/crates/rspack_cacheable/src/with/as_vec.rs
@@ -79,7 +79,7 @@ where
 impl<T, A, O, D> DeserializeWith<ArchivedVec<A::Archived>, T, D> for AsVec<A>
 where
   T: AsVecConverter<Item = O>,
-  D: Fallible<Error = DeserializeError>,
+  D: Fallible<Error = DeserializeError> + ?Sized,
   A: ArchiveWith<O> + DeserializeWith<A::Archived, O, D>,
 {
   fn deserialize_with(field: &ArchivedVec<A::Archived>, d: &mut D) -> Result<T, DeserializeError> {
diff --git a/crates/rspack_cacheable/src/with/inline.rs b/crates/rspack_cacheable/src/with/inline.rs
@@ -26,7 +26,7 @@ where
 impl<'a, T, F, S> SerializeWith<&'a F, S> for Inline<T>
 where
   T: SerializeWith<F, S>,
-  S: ?Sized + Fallible,
+  S: Fallible + ?Sized,
 {
   #[inline]
   fn serialize_with(field: &&F, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
diff --git a/crates/rspack_cacheable/src/with/unsupported.rs b/crates/rspack_cacheable/src/with/unsupported.rs
@@ -17,7 +17,7 @@ impl<F> ArchiveWith<F> for Unsupported {
 
 impl<F, S> SerializeWith<F, S> for Unsupported
 where
-  S: Fallible<Error = SerializeError>,
+  S: Fallible<Error = SerializeError> + ?Sized,
 {
   fn serialize_with(_: &F, _: &mut S) -> Result<(), SerializeError> {
     Err(SerializeError::UnsupportedField)
@@ -26,7 +26,7 @@ where
 
 impl<F, D> DeserializeWith<(), F, D> for Unsupported
 where
-  D: Fallible<Error = DeserializeError>,
+  D: Fallible<Error = DeserializeError> + ?Sized,
 {
   fn deserialize_with(_: &(), _: &mut D) -> Result<F, DeserializeError> {
     Err(DeserializeError::UnsupportedField)
diff --git a/crates/rspack_cacheable_test/tests/macro/cacheable/as_attr.rs b/crates/rspack_cacheable_test/tests/macro/cacheable/as_attr.rs
@@ -1,34 +1,62 @@
 use rspack_cacheable::{
-  cacheable, from_bytes, to_bytes,
-  with::{AsTuple2, Inline},
+  cacheable, cacheable_dyn, from_bytes, to_bytes,
+  with::{AsOption, AsTuple2, AsVec, Inline},
 };
 
+#[cacheable_dyn]
+trait Module {}
+
+#[cacheable]
+struct NormalModule {
+  inner: String,
+}
+
+#[cacheable_dyn]
+impl Module for NormalModule {}
+
 #[cacheable]
-#[derive(Debug, PartialEq, Eq)]
-struct Person {
-  name: String,
-  content: (String, String),
+struct Data {
+  block1: String,
+  block2: Vec<(String, Option<String>)>,
+  block3: Box<dyn Module>,
 }
 
-#[cacheable(as=Person)]
-struct PersonRef<'a> {
-  #[rkyv(with=Inline)]
-  name: &'a String,
-  #[rkyv(with=AsTuple2<Inline, Inline>)]
-  content: (&'a String, &'a String),
+#[cacheable(as=Data)]
+struct DataRef<'a> {
+  #[cacheable(with=Inline)]
+  block1: &'a String,
+  #[cacheable(with=AsVec<AsTuple2<Inline, AsOption<Inline>>>)]
+  block2: Vec<(&'a String, Option<&'a String>)>,
+  #[allow(clippy::borrowed_box)]
+  #[cacheable(with=Inline)]
+  block3: &'a Box<dyn Module>,
 }
 
 #[test]
+#[cfg_attr(miri, ignore)]
 fn as_attr() {
-  let a = Person {
-    name: "abc".into(),
-    content: ("a".into(), "b".into()),
+  let a = Data {
+    block1: "abc".into(),
+    block2: vec![
+      ("key1".into(), None),
+      ("key2".into(), Some("value2".into())),
+      ("key3".into(), Some("value3".into())),
+    ],
+    block3: Box::new(NormalModule {
+      inner: "inner".into(),
+    }),
   };
-  let a_ref = PersonRef {
-    name: &a.name,
-    content: (&a.content.0, &a.content.1),
+  let a_ref = DataRef {
+    block1: &a.block1,
+    block2: a
+      .block2
+      .iter()
+      .map(|(key, value)| (key, value.as_ref()))
+      .collect(),
+    block3: &a.block3,
   };
-  let bytes = to_bytes(&a_ref, &()).unwrap();
-  let deserialize_a: Person = from_bytes(&bytes, &()).unwrap();
-  assert_eq!(a, deserialize_a);
+  let bytes = to_bytes(&a, &()).unwrap();
+  let bytes_ref = to_bytes(&a_ref, &()).unwrap();
+  assert_eq!(bytes, bytes_ref);
+  from_bytes::<Data, ()>(&bytes, &()).unwrap();
 }
diff --git a/crates/rspack_cacheable_test/tests/macro/manual_cacheable/as_attr.rs b/crates/rspack_cacheable_test/tests/macro/manual_cacheable/as_attr.rs
diff --git a/crates/rspack_macros/src/cacheable/impl_as.rs b/crates/rspack_macros/src/cacheable/impl_as.rs

Original file line number	Diff line number	Diff line change
`@@ -20,15 +20,15 @@ impl<'a> ContextGuard<'a> {`
`20`	`20`	`Self { context }`
`21`	`21`	`}`
`22`	`22`
`23`		`- pub fn add_to_sharing<S: Sharing<SerializeError>>(`
	`23`	`+ pub fn add_to_sharing<S: Sharing<SerializeError> + ?Sized>(`
`24`	`24`	`&self,`
`25`	`25`	`sharing: &mut S,`
`26`	`26`	`) -> Result<(), SerializeError> {`
`27`	`27`	`sharing.start_sharing(CONTEXT_ADDR);`
`28`	`28`	`sharing.finish_sharing(CONTEXT_ADDR, self as *const _ as usize)`
`29`	`29`	`}`
`30`	`30`
`31`		`- pub fn sharing_context<S: Sharing<SerializeError>>(`
	`31`	`+ pub fn sharing_context<S: Sharing<SerializeError> + ?Sized>(`
`32`	`32`	`sharing: &'a mut S,`
`33`	`33`	`) -> Result<&'a dyn Any, SerializeError> {`
`34`	`34`	`match sharing.start_sharing(CONTEXT_ADDR) {`
`@@ -40,7 +40,7 @@ impl<'a> ContextGuard<'a> {`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`- pub fn add_to_pooling<P: Pooling<DeserializeError>>(`
	`43`	`+ pub fn add_to_pooling<P: Pooling<DeserializeError> + ?Sized>(`
`44`	`44`	`&self,`
`45`	`45`	`pooling: &mut P,`
`46`	`46`	`) -> Result<(), DeserializeError> {`
`@@ -51,7 +51,7 @@ impl<'a> ContextGuard<'a> {`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`- pub fn pooling_context<P: Pooling<DeserializeError>>(`
	`54`	`+ pub fn pooling_context<P: Pooling<DeserializeError> + ?Sized>(`
`55`	`55`	`pooling: &'a mut P,`
`56`	`56`	`) -> Result<&'a dyn Any, DeserializeError> {`
`57`	`57`	`match pooling.start_pooling(CONTEXT_ADDR) {`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ impl<T, A, O, D> DeserializeWith<A::Archived, T, D> for AsInner<A>`
`48`	`48`	`where`
`49`	`49`	`T: AsInnerConverter<Inner = O>,`
`50`	`50`	`A: ArchiveWith<O> + DeserializeWith<A::Archived, O, D>,`
`51`		`- D: ?Sized + Fallible,`
	`51`	`+ D: Fallible + ?Sized,`
`52`	`52`	`{`
`53`	`53`	`fn deserialize_with(field: &A::Archived, d: &mut D) -> Result<T, D::Error> {`
`54`	`54`	`Ok(T::from_inner(A::deserialize_with(field, d)?))`
Original file line number	Diff line number	Diff line change
`@@ -57,10 +57,11 @@ where`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`-impl<WK, WV, K, V, S: Fallible + ?Sized> Serialize<S> for Entry<&'_ K, &'_ V, WK, WV>`
	`60`	`+impl<WK, WV, K, V, S> Serialize<S> for Entry<&'_ K, &'_ V, WK, WV>`
`61`	`61`	`where`
`62`	`62`	`WK: SerializeWith<K, S>,`
`63`	`63`	`WV: SerializeWith<V, S>,`
	`64`	`+ S: Fallible + ?Sized,`
`64`	`65`	`{`
`65`	`66`	`#[inline]`
`66`	`67`	`fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {`
`@@ -90,7 +91,7 @@ where`
`90`	`91`	`T: AsMapConverter<Key = K, Value = V>,`
`91`	`92`	`WK: ArchiveWith<K>,`
`92`	`93`	`WV: ArchiveWith<V>,`
`93`		`- S: Fallible + ?Sized + Allocator + Writer,`
	`94`	`+ S: Fallible + Allocator + Writer + ?Sized,`
`94`	`95`	`for<'a> Entry<&'a K, &'a V, WK, WV>: Serialize<S>,`
`95`	`96`	`{`
`96`	`97`	`fn serialize_with(field: &T, s: &mut S) -> Result<Self::Resolver, S::Error> {`
Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,11 @@ where`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`-impl<A, B, K, V, S: Fallible + ?Sized> SerializeWith<(K, V), S> for AsTuple2<A, B>`
	`33`	`+impl<A, B, K, V, S> SerializeWith<(K, V), S> for AsTuple2<A, B>`
`34`	`34`	`where`
`35`	`35`	`A: SerializeWith<K, S>,`
`36`	`36`	`B: SerializeWith<V, S>,`
	`37`	`+ S: Fallible + ?Sized,`
`37`	`38`	`{`
`38`	`39`	`#[inline]`
`39`	`40`	`fn serialize_with(field: &(K, V), serializer: &mut S) -> Result<Self::Resolver, S::Error> {`
`@@ -49,7 +50,7 @@ impl<A, B, K, V, D> DeserializeWith<ArchivedTuple2<A::Archived, B::Archived>, (K`
`49`	`50`	`where`
`50`	`51`	`A: ArchiveWith<K> + DeserializeWith<A::Archived, K, D>,`
`51`	`52`	`B: ArchiveWith<V> + DeserializeWith<B::Archived, V, D>,`
`52`		`- D: ?Sized + Fallible,`
	`53`	`+ D: Fallible + ?Sized,`
`53`	`54`	`{`
`54`	`55`	`fn deserialize_with(`
`55`	`56`	`field: &ArchivedTuple2<A::Archived, B::Archived>,`
Original file line number	Diff line number	Diff line change
`@@ -34,11 +34,12 @@ where`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`-impl<A, B, C, K, V, H, S: Fallible + ?Sized> SerializeWith<(K, V, H), S> for AsTuple3<A, B, C>`
	`37`	`+impl<A, B, C, K, V, H, S> SerializeWith<(K, V, H), S> for AsTuple3<A, B, C>`
`38`	`38`	`where`
`39`	`39`	`A: SerializeWith<K, S>,`
`40`	`40`	`B: SerializeWith<V, S>,`
`41`	`41`	`C: SerializeWith<H, S>,`
	`42`	`+ S: Fallible + ?Sized,`
`42`	`43`	`{`
`43`	`44`	`#[inline]`
`44`	`45`	`fn serialize_with(field: &(K, V, H), serializer: &mut S) -> Result<Self::Resolver, S::Error> {`
`@@ -57,7 +58,7 @@ where`
`57`	`58`	`A: ArchiveWith<K> + DeserializeWith<A::Archived, K, D>,`
`58`	`59`	`B: ArchiveWith<V> + DeserializeWith<B::Archived, V, D>,`
`59`	`60`	`C: ArchiveWith<H> + DeserializeWith<C::Archived, H, D>,`
`60`		`- D: ?Sized + Fallible,`
	`61`	`+ D: Fallible + ?Sized,`
`61`	`62`	`{`
`62`	`63`	`fn deserialize_with(`
`63`	`64`	`field: &ArchivedTuple3<A::Archived, B::Archived, C::Archived>,`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ where`
`79`	`79`	`impl<T, A, O, D> DeserializeWith<ArchivedVec<A::Archived>, T, D> for AsVec<A>`
`80`	`80`	`where`
`81`	`81`	`T: AsVecConverter<Item = O>,`
`82`		`- D: Fallible<Error = DeserializeError>,`
	`82`	`+ D: Fallible<Error = DeserializeError> + ?Sized,`
`83`	`83`	`A: ArchiveWith<O> + DeserializeWith<A::Archived, O, D>,`
`84`	`84`	`{`
`85`	`85`	`fn deserialize_with(field: &ArchivedVec<A::Archived>, d: &mut D) -> Result<T, DeserializeError> {`