baked

provider/baked/Cargo.toml

@@ -29,6 +29,7 @@ heck = { workspace = true, optional = true }
 [dev-dependencies]
 icu_provider = { path = "../core", features = ["export"] }
 icu_datagen = { path = "../datagen" }
+icu_locale = { path = "../../components/locale" }
 
 [features]
 export = [

provider/baked/src/export.rs

@@ -299,6 +299,7 @@ impl BakedExporter {
         &self,
         marker: DataMarkerInfo,
         body: TokenStream,
+        dry_body: TokenStream,
         iterable_body: TokenStream,
     ) -> Result<(), DataError> {
         let marker_unqualified = bake_marker(marker).into_iter().last().unwrap().to_string();
@@ -333,8 +334,10 @@ impl BakedExporter {
                         const _: () = <$provider>::MUST_USE_MAKE_PROVIDER_MACRO;
                         #body
                     };
-                    ($provider:ty, ITER) => {
-                        #prefixed_macro_ident!($provider);
+                    (DryDataProvider for $provider:ty) => {
+                        #dry_body
+                    }
+                    (IterableDataProvider for $provider:ty) => {
                         #iterable_body
                     };
                 }
@@ -414,6 +417,17 @@ impl DataExporter for BakedExporter {
                     }
                 }
             }
+        }, quote! {
+            #maybe_msrv
+            impl icu_provider::DryDataProvider<#marker_bake> for $provider {
+                #[inline]
+                fn dry_load(
+                    &self,
+                    req: icu_provider::DataRequest,
+                ) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                    icu_provider::DataProvider::<#marker_bake>::load(self, req).map(|r| r.metadata)
+                }
+            }
         }, quote! {
             #maybe_msrv
             impl icu_provider::IterableDataProvider<#marker_bake> for $provider {
@@ -449,6 +463,17 @@ impl DataExporter for BakedExporter {
                             Err(icu_provider::DataErrorKind::IdentifierNotFound.with_req(<#marker_bake as icu_provider::DataMarker>::INFO, req))
                         }
                     }
+                }, quote! {
+                    #maybe_msrv
+                    impl icu_provider::DryDataProvider<#marker_bake> for $provider {
+                        #[inline]
+                        fn dry_load(
+                            &self,
+                            req: icu_provider::DataRequest,
+                        ) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                            icu_provider::DataProvider::<#marker_bake>::load(self, req).map(|r| r.metadata)
+                        }
+                    }
                 },
                 quote! {
                     #maybe_msrv
@@ -564,6 +589,17 @@ impl DataExporter for BakedExporter {
                             })
                         }
                     }
+                }, quote! {
+                    #maybe_msrv
+                    impl icu_provider::DryDataProvider<#marker_bake> for $provider {
+                        #[inline]
+                        fn dry_load(
+                            &self,
+                            req: icu_provider::DataRequest,
+                        ) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                            icu_provider::DataProvider::<#marker_bake>::load(self, req).map(|r| r.metadata)
+                        }
+                    }
                 },
                 quote! {
                     #maybe_msrv

provider/baked/tests/data/hello_world_v1_marker.rs.data

@@ -51,8 +51,16 @@ macro_rules! __impl_hello_world_v1_marker {
             }
         }
     };
-    ($ provider : ty , ITER) => {
-        __impl_hello_world_v1_marker!($provider);
+    (DryDataProvider for $ provider : ty) => {
+        #[clippy::msrv = "1.70"]
+        impl icu_provider::DryDataProvider<icu_provider::hello_world::HelloWorldV1Marker> for $provider {
+            #[inline]
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                icu_provider::DataProvider::<icu_provider::hello_world::HelloWorldV1Marker>::load(self, req).map(|r| r.metadata)
+            }
+        }
+    };
+    (IterableDataProvider for $ provider : ty) => {
         #[clippy::msrv = "1.70"]
         impl icu_provider::IterableDataProvider<icu_provider::hello_world::HelloWorldV1Marker> for $provider {
             fn iter_ids(&self) -> Result<std::collections::HashSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {

provider/baked/tests/test-baked-source.rs

@@ -14,7 +14,9 @@ const _: () = {
     #[path = "data/mod.rs"]
     mod baked_data;
     baked_data::make_provider!(Baked);
-    baked_data::impl_hello_world_v1_marker!(Baked, ITER);
+    baked_data::impl_hello_world_v1_marker!(Baked);
+    baked_data::impl_hello_world_v1_marker!(DryDataProvider for Baked);
+    baked_data::impl_hello_world_v1_marker!(IterableDataProvider for Baked);
 };
 
 #[test]
@@ -40,3 +42,20 @@ fn load() {
         assert_eq!(baked, expected);
     }
 }
+
+
+#[test]
+fn dry_load() {
+    use icu_provider::hello_world::HelloWorldProvider;
+    use icu_provider::prelude::*;
+
+    for id in HelloWorldProvider.iter_ids().unwrap().into_iter().chain([DataIdentifierCow::from_locale("foo".parse().unwrap())]) {
+        let req = DataRequest {
+            id: id.as_borrowed(),
+            ..Default::default()
+        };
+        let expected = HelloWorldProvider.dry_load(req);
+        let baked = Baked.dry_load(req);
+        assert_eq!(baked, expected);
+    }
+}