ref

Author: robertbastian

provider/core/src/datagen/payload.rs

@@ -8,18 +8,17 @@ use alloc::boxed::Box;
 use databake::{Bake, CrateEnv, TokenStream};
 use yoke::*;
 
-trait ExportableYoke {
+trait ExportableDataPayload {
     fn bake_yoke(&self, env: &CrateEnv) -> TokenStream;
     fn serialize_yoke(
         &self,
         serializer: &mut dyn erased_serde::Serializer,
     ) -> Result<(), DataError>;
 }
 
-impl<Y, C> ExportableYoke for Yoke<Y, C>
+impl<M: DataMarker> ExportableDataPayload for DataPayload<M>
 where
-    Y: for<'a> Yokeable<'a>,
-    for<'a> <Y as Yokeable<'a>>::Output: Bake + serde::Serialize,
+    for<'a> <M::Yokeable as Yokeable<'a>>::Output: Bake + serde::Serialize,
 {
     fn bake_yoke(&self, ctx: &CrateEnv) -> TokenStream {
         self.get().bake(ctx)
@@ -40,7 +39,7 @@ where
 #[doc(hidden)] // exposed for make_exportable_provider
 #[derive(yoke::Yokeable)]
 pub struct ExportBox {
-    payload: Box<dyn ExportableYoke + Sync>,
+    payload: Box<dyn ExportableDataPayload + Sync>,
 }
 
 impl core::fmt::Debug for ExportBox {
@@ -59,7 +58,7 @@ where
 {
     fn upcast(other: DataPayload<M>) -> DataPayload<ExportMarker> {
         DataPayload::from_owned(ExportBox {
-            payload: Box::new(other.yoke),
+            payload: Box::new(other),
         })
     }
 }

provider/core/src/response.rs

@@ -71,11 +71,11 @@ pub struct DataResponseMetadata {
 ///
 /// assert_eq!("Demo", payload.get().message);
 /// ```
-pub struct DataPayload<M>
-where
-    M: DataMarker,
-{
-    pub(crate) yoke: Yoke<M::Yokeable, Option<Cart>>,
+pub struct DataPayload<M: DataMarker>(pub(crate) DataPayloadInner<M>);
+
+pub(crate) enum DataPayloadInner<M: DataMarker> {
+    Yoke(Yoke<M::Yokeable, Option<Cart>>),
+    Ref(&'static M::Yokeable),
 }
 
 /// The type of the "cart" that is used by `DataPayload`.
@@ -136,9 +136,10 @@ where
     for<'a> YokeTraitHack<<M::Yokeable as Yokeable<'a>>::Output>: Clone,
 {
     fn clone(&self) -> Self {
-        Self {
-            yoke: self.yoke.clone(),
-        }
+        Self(match &self.0 {
+            DataPayloadInner::Yoke(yoke) => DataPayloadInner::Yoke(yoke.clone()),
+            DataPayloadInner::Ref(r) => DataPayloadInner::Ref(*r),
+        })
     }
 }
 
@@ -193,17 +194,23 @@ where
     /// ```
     #[inline]
     pub fn from_owned(data: M::Yokeable) -> Self {
-        Self {
-            yoke: Yoke::new_owned(data),
-        }
+        Self(DataPayloadInner::Yoke(Yoke::new_owned(data)))
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    pub fn from_static_ref(data: &'static M::Yokeable) -> Self {
+        Self(DataPayloadInner::Ref(data))
     }
 
     /// Convert a DataPayload that was created via [`DataPayload::from_owned()`] back into the
     /// concrete type used to construct it.
     pub fn try_unwrap_owned(self) -> Result<M::Yokeable, DataError> {
-        self.yoke
-            .try_into_yokeable()
-            .map_err(|_| DataErrorKind::InvalidState.with_str_context("try_unwrap_owned"))
+        match self.0 {
+            DataPayloadInner::Yoke(yoke) => yoke.try_into_yokeable().ok(),
+            DataPayloadInner::Ref(_) => None,
+        }
+        .ok_or(DataErrorKind::InvalidState.with_str_context("try_unwrap_owned"))
     }
 
     /// Mutate the data contained in this DataPayload.
@@ -244,8 +251,15 @@ where
     pub fn with_mut<'a, F>(&'a mut self, f: F)
     where
         F: 'static + for<'b> FnOnce(&'b mut <M::Yokeable as Yokeable<'a>>::Output),
+        M::Yokeable: Clone,
     {
-        self.yoke.with_mut(f)
+        if let DataPayloadInner::Ref(r) = self.0 {
+            self.0 = DataPayloadInner::Yoke(Yoke::new_owned(M::Yokeable::clone(r)));
+        }
+        match &mut self.0 {
+            DataPayloadInner::Yoke(yoke) => yoke.with_mut(f),
+            _ => unreachable!(),
+        }
     }
 
     /// Borrows the underlying data.
@@ -266,7 +280,10 @@ where
     #[inline]
     #[allow(clippy::needless_lifetimes)]
     pub fn get<'a>(&'a self) -> &'a <M::Yokeable as Yokeable<'a>>::Output {
-        self.yoke.get()
+        match &self.0 {
+            DataPayloadInner::Yoke(yoke) => yoke.get(),
+            DataPayloadInner::Ref(r) => Yokeable::transform(*r),
+        }
     }
 
     /// Maps `DataPayload<M>` to `DataPayload<M2>` by projecting it with [`Yoke::map_project`].
@@ -318,10 +335,14 @@ where
             <M::Yokeable as Yokeable<'a>>::Output,
             PhantomData<&'a ()>,
         ) -> <M2::Yokeable as Yokeable<'a>>::Output,
+        M::Yokeable: Clone,
     {
-        DataPayload {
-            yoke: self.yoke.map_project(f),
-        }
+        DataPayload(match self.0 {
+            DataPayloadInner::Yoke(yoke) => DataPayloadInner::Yoke(yoke.map_project(f)),
+            DataPayloadInner::Ref(r) => {
+                DataPayloadInner::Yoke(Yoke::new_owned(r.clone()).map_project(f))
+            }
+        })
     }
 
     /// Version of [`DataPayload::map_project()`] that borrows `self` instead of moving `self`.
@@ -362,8 +383,16 @@ where
             PhantomData<&'a ()>,
         ) -> <M2::Yokeable as Yokeable<'a>>::Output,
     {
-        DataPayload {
-            yoke: self.yoke.map_project_cloned(f),
+        match &self.0 {
+            DataPayloadInner::Yoke(yoke) => {
+                DataPayload(DataPayloadInner::Yoke(yoke.map_project_cloned(f)))
+            }
+            DataPayloadInner::Ref(r) => {
+                let output: <M2::Yokeable as Yokeable<'static>>::Output =
+                    f(Yokeable::transform(*r), PhantomData);
+                let yokeable: M2::Yokeable = unsafe { M2::Yokeable::make(output) };
+                DataPayload(DataPayloadInner::Yoke(Yoke::new_owned(yokeable)))
+            }
         }
     }
 
@@ -411,10 +440,14 @@ where
             <M::Yokeable as Yokeable<'a>>::Output,
             PhantomData<&'a ()>,
         ) -> Result<<M2::Yokeable as Yokeable<'a>>::Output, E>,
+        M::Yokeable: Clone,
     {
-        Ok(DataPayload {
-            yoke: self.yoke.try_map_project(f)?,
-        })
+        Ok(DataPayload(match self.0 {
+            DataPayloadInner::Yoke(yoke) => DataPayloadInner::Yoke(yoke.try_map_project(f)?),
+            DataPayloadInner::Ref(r) => {
+                DataPayloadInner::Yoke(Yoke::new_owned(r.clone()).try_map_project(f)?)
+            }
+        }))
     }
 
     /// Version of [`DataPayload::map_project_cloned()`] that  bubbles up an error from `f`.
@@ -465,8 +498,16 @@ where
             PhantomData<&'a ()>,
         ) -> Result<<M2::Yokeable as Yokeable<'a>>::Output, E>,
     {
-        Ok(DataPayload {
-            yoke: self.yoke.try_map_project_cloned(f)?,
+        Ok(match &self.0 {
+            DataPayloadInner::Yoke(yoke) => {
+                DataPayload(DataPayloadInner::Yoke(yoke.try_map_project_cloned(f)?))
+            }
+            DataPayloadInner::Ref(r) => {
+                let output: <M2::Yokeable as Yokeable<'static>>::Output =
+                    f(Yokeable::transform(*r), PhantomData)?;
+                let yokeable: M2::Yokeable = unsafe { M2::Yokeable::make(output) };
+                DataPayload(DataPayloadInner::Yoke(Yoke::new_owned(yokeable)))
+            }
         })
     }
 
@@ -497,7 +538,10 @@ where
     where
         M2: DataMarker<Yokeable = M::Yokeable>,
     {
-        DataPayload { yoke: self.yoke }
+        DataPayload(match self.0 {
+            DataPayloadInner::Yoke(yoke) => DataPayloadInner::Yoke(yoke),
+            DataPayloadInner::Ref(r) => DataPayloadInner::Ref(r),
+        })
     }
 }
 
@@ -507,19 +551,17 @@ impl DataPayload<BufferMarker> {
         let yoke = Yoke::attach_to_cart(SelectedRc::new(buffer), |b| &**b);
         // Safe because cart is wrapped
         let yoke = unsafe { yoke.replace_cart(|b| Some(Cart(b))) };
-        Self { yoke }
+        Self(DataPayloadInner::Yoke(yoke))
     }
 
     /// Converts a yoked byte buffer into a `DataPayload<BufferMarker>`.
     pub fn from_yoked_buffer(yoke: Yoke<&'static [u8], Option<Cart>>) -> Self {
-        Self { yoke }
+        Self(DataPayloadInner::Yoke(yoke))
     }
 
     /// Converts a static byte buffer into a `DataPayload<BufferMarker>`.
-    pub fn from_static_buffer(buffer: &'static [u8]) -> Self {
-        Self {
-            yoke: Yoke::new_owned(buffer),
-        }
+    pub fn from_static_buffer(buffer: &'static &'static [u8]) -> Self {
+        Self(DataPayloadInner::Ref(buffer))
     }
 }
 

provider/datagen/src/baked_exporter.rs

@@ -142,6 +142,8 @@ struct ImplData {
     feature: SyncTokenStream,
     macro_ident: SyncTokenStream,
     hash_ident: SyncTokenStream,
+    // These are required for the skeletons special case
+    into_data_payload: SyncTokenStream,
     into_any_payload: SyncTokenStream,
 }
 
@@ -397,10 +399,20 @@ impl DataExporter for BakedExporter {
             }
         };
 
-        let into_any_payload = if is_datetime_skeletons {
+        let into_data_payload = if is_datetime_skeletons {
             quote! {
                 .map(icu_provider::prelude::zerofrom::ZeroFrom::zero_from)
                 .map(icu_provider::DataPayload::<#marker>::from_owned)
+            }
+        } else {
+            quote! {
+                .map(icu_provider::DataPayload::from_static_ref)
+            }
+        };
+
+        let into_any_payload = if is_datetime_skeletons {
+            quote! {
+                #into_data_payload
                 .map(icu_provider::DataPayload::wrap_into_any_payload)
             }
         } else {
@@ -416,6 +428,7 @@ impl DataExporter for BakedExporter {
             singleton: singleton.map(|t| t.to_string()),
             macro_ident: format!("impl_{ident}"),
             hash_ident: ident.to_ascii_uppercase(),
+            into_data_payload: into_data_payload.to_string(),
             into_any_payload: into_any_payload.to_string(),
         };
 
@@ -477,6 +490,10 @@ impl DataExporter for BakedExporter {
             .values()
             .map(|data| data.hash_ident.parse::<TokenStream>().unwrap())
             .collect::<Vec<_>>();
+        let into_data_payloads = data
+            .values()
+            .map(|data| data.into_data_payload.parse::<TokenStream>().unwrap())
+            .collect::<Vec<_>>();
         let into_any_payloads = data
             .values()
             .map(|data| data.into_any_payload.parse::<TokenStream>().unwrap())
@@ -548,8 +565,7 @@ impl DataExporter for BakedExporter {
                                     req: icu_provider::DataRequest,
                                 ) -> Result<icu_provider::DataResponse<#markers>, icu_provider::DataError> {
                                     #lookups
-                                        .map(icu_provider::prelude::zerofrom::ZeroFrom::zero_from)
-                                        .map(icu_provider::DataPayload::from_owned)
+                                        #into_data_payloads
                                         .map(|payload| {
                                             icu_provider::DataResponse {
                                                 metadata: Default::default(),