Dropping legacy databake interface (#5059)

All interesting changes are in the first commit

Author: robertbastian

provider/baked/src/export.rs

@@ -102,14 +102,6 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::sync::Mutex;
 
-macro_rules! move_out {
-    ($field:expr) => {{
-        let mut tmp = Default::default();
-        core::mem::swap(&mut tmp, &mut $field);
-        tmp
-    }};
-}
-
 // TokenStream isn't Send/Sync
 type SyncTokenStream = String;
 
@@ -170,7 +162,7 @@ pub struct BakedExporter {
             BTreeMap<SyncTokenStream, HashSet<(DataLocale, DataMarkerAttributes)>>,
         >,
     >,
-    /// (Key, Marker) pairs to wire up in mod.rs. This is populated by `flush` and consumed by `close`.
+    /// (marker, file name) pairs to wire up in mod.rs. This is populated by `flush` and consumed by `close`.
     impl_data: Mutex<BTreeMap<DataMarkerInfo, SyncTokenStream>>,
     // List of dependencies used by baking.
     dependencies: CrateEnv,
@@ -276,7 +268,7 @@ impl BakedExporter {
     }
 
     fn print_deps(&mut self) {
-        let mut deps = move_out!(self.dependencies)
+        let mut deps = core::mem::take(&mut self.dependencies)
             .into_iter()
             .collect::<BTreeSet<_>>();
         if !self.use_separate_crates {
@@ -298,33 +290,44 @@ impl BakedExporter {
 
     fn write_impl_macros(
         &self,
+        marker: DataMarkerInfo,
         body: TokenStream,
         iterable_body: TokenStream,
-        marker: DataMarkerInfo,
-        marker_bake: TokenStream,
     ) -> Result<(), DataError> {
-        let marker_string = marker_bake.to_string();
-        let marker_last = marker_bake.into_iter().last().unwrap();
+        let marker_unqualified = bake_marker(marker).into_iter().last().unwrap();
+
         let doc = format!(
             " Implement `DataProvider<{}>` on the given struct using the data",
-            marker_last
+            marker_unqualified
         );
         let doc_iterable = format!(
             " Implement `IterableDataProvider<{}>` on the given struct using the data",
-            marker_last
+            marker_unqualified
         );
 
-        let ident = Self::ident(marker);
+        let ident = marker
+            .path
+            .replace('/', "_")
+            .replace('@', "_v")
+            .to_ascii_lowercase();
+
+        let macro_ident = format!("impl_{ident}",).parse::<TokenStream>().unwrap();
+        let macro_ident_iterable = format!("impliterable_{ident}")
+            .parse::<TokenStream>()
+            .unwrap();
 
-        let prefixed_macro_ident = format!("__impl_{ident}").parse::<TokenStream>().unwrap();
-        let prefixed_macro_ident_iterable = format!("__impliterable_{ident}")
+        // We prefix all macros with `__`, as these will be automatically exported at the crate root, which is annoying
+        // for crates that include the data but don't want it to be public. We then reexport them as items that use
+        // normal scoping that clients can control.
+        let prefixed_macro_ident = format!("__{macro_ident}").parse::<TokenStream>().unwrap();
+        let prefixed_macro_ident_iterable = format!("__{macro_ident_iterable}")
             .parse::<TokenStream>()
             .unwrap();
 
         let maybe_msrv = maybe_msrv();
 
         self.write_to_file(
-            PathBuf::from(format!("macros/{}.rs.data", ident)),
+            PathBuf::from(format!("{ident}.rs.data")),
             quote! {
                 #[doc = #doc]
                 /// hardcoded in this file. This allows the struct to be used with
@@ -338,6 +341,9 @@ impl BakedExporter {
                         #body
                     }
                 }
+                #[doc(inline)]
+                pub use #prefixed_macro_ident as #macro_ident;
+
                 #[doc = #doc_iterable]
                 /// hardcoded in this file. This allows the struct to be used with
                 /// `DatagenDriver` for this marker.
@@ -348,23 +354,14 @@ impl BakedExporter {
                         #iterable_body
                     }
                 }
+                #[doc(inline)]
+                pub use #prefixed_macro_ident_iterable as #macro_ident_iterable;
             },
         )?;
 
-        self.impl_data
-            .lock()
-            .expect("poison")
-            .insert(marker, marker_string);
+        self.impl_data.lock().expect("poison").insert(marker, ident);
         Ok(())
     }
-
-    fn ident(marker: DataMarkerInfo) -> String {
-        marker
-            .path
-            .to_ascii_lowercase()
-            .replace('@', "_v")
-            .replace('/', "_")
-    }
 }
 
 impl DataExporter for BakedExporter {
@@ -393,17 +390,25 @@ impl DataExporter for BakedExporter {
         marker: DataMarkerInfo,
         payload: &DataPayload<ExportMarker>,
     ) -> Result<(), DataError> {
-        let marker_bake = bake_marker(marker, &self.dependencies);
-
-        let singleton_ident = format!("SINGLETON_{}", Self::ident(marker).to_ascii_uppercase())
-            .parse::<TokenStream>()
-            .unwrap();
+        let marker_bake = bake_marker(marker);
+
+        let singleton_ident = format!(
+            "SINGLETON_{}",
+            marker
+                .path
+                .get()
+                .replace('/', "_")
+                .replace('@', "_v")
+                .to_ascii_uppercase()
+        )
+        .parse::<TokenStream>()
+        .unwrap();
 
         let bake = payload.tokenize(&self.dependencies);
 
         let maybe_msrv = maybe_msrv();
 
-        self.write_impl_macros(quote! {
+        self.write_impl_macros(marker, quote! {
             #maybe_msrv
             impl $provider {
                 // Exposing singleton structs as consts allows us to get rid of fallibility
@@ -434,11 +439,11 @@ impl DataExporter for BakedExporter {
                     Ok(HashSet::from_iter([Default::default()]))
                 }
             }
-        }, marker, marker_bake)
+        })
     }
 
     fn flush(&self, marker: DataMarkerInfo) -> Result<(), DataError> {
-        let marker_bake = bake_marker(marker, &self.dependencies);
+        let marker_bake = bake_marker(marker);
 
         let (struct_type, into_data_payload) = if marker_bake
             .to_string()
@@ -608,6 +613,7 @@ impl DataExporter for BakedExporter {
         };
 
         self.write_impl_macros(
+            marker,
             quote! {
                 #maybe_msrv
                 impl icu_provider::DataProvider<#marker_bake> for $provider {
@@ -627,54 +633,34 @@ impl DataExporter for BakedExporter {
                     }
                 }
             },
-            marker,
-            marker_bake,
         )
     }
 
     fn close(&mut self) -> Result<(), DataError> {
         log::info!("Writing macros module...");
 
-        let data = move_out!(self.impl_data).into_inner().expect("poison");
-
-        let marker_bakes = data
-            .values()
-            .map(|marker| marker.parse::<TokenStream>().unwrap())
-            .collect::<Vec<_>>();
-
-        let (
-            macro_idents,
-            prefixed_macro_idents,
-            macro_idents_iterable,
-            prefixed_macro_idents_iterable,
-            mod_idents,
-            file_paths,
-        ): (Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) =
-            itertools::multiunzip(data.keys().map(|&marker| {
-                let ident = Self::ident(marker);
-                (
-                    format!("impl_{}", ident).parse::<TokenStream>().unwrap(),
-                    // We prefix all macros with `__`, as these will be automatically exported at the crate root, which is annoying
-                    // for crates that include the data but don't want it to be public. We then reexport them as items that use
-                    // normal scoping that clients can control.
-                    format!("__impl_{}", ident).parse::<TokenStream>().unwrap(),
-                    format!("impliterable_{}", ident)
-                        .parse::<TokenStream>()
-                        .unwrap(),
-                    format!("__impliterable_{}", ident)
-                        .parse::<TokenStream>()
-                        .unwrap(),
-                    ident.parse::<TokenStream>().unwrap(),
-                    format!("macros/{}.rs.data", ident),
-                )
-            }));
+        let data = core::mem::take(&mut self.impl_data)
+            .into_inner()
+            .expect("poison");
 
         let maybe_msrv = maybe_msrv();
 
-        // macros.rs is the interface for built-in data. It exposes one macro per marker.
+        let marker_bakes = data.keys().copied().map(bake_marker);
+
+        let file_paths = data.values().map(|i| format!("{i}.rs.data"));
+
+        let macro_idents = data
+            .values()
+            .map(|i| format!("impl_{i}").parse::<TokenStream>().unwrap());
+
+        // mod.rs is the interface for built-in data. It exposes one macro per marker.
         self.write_to_file(
-            PathBuf::from("macros.rs"),
+            PathBuf::from("mod.rs"),
             quote! {
+                #(
+                    include!(#file_paths);
+                )*
+
                 /// Marks a type as a data provider. You can then use macros like
                 /// `impl_core_helloworld_v1` to add implementations.
                 ///
@@ -700,26 +686,9 @@ impl DataExporter for BakedExporter {
                 }
                 #[doc(inline)]
                 pub use __make_provider as make_provider;
-                #(
-                    #[macro_use]
-                    #[path = #file_paths]
-                    mod #mod_idents;
-                    #[doc(inline)]
-                    pub use #prefixed_macro_idents as #macro_idents;
-                    #[doc(inline)]
-                    pub use #prefixed_macro_idents_iterable as #macro_idents_iterable;
-                )*
-            },
-        )?;
 
-        // mod.rs is the interface for using databake directly. It exposes the macros from macros.rs,
-        // as well as `impl_data_provider` and `impl_any_provider` which include all markers.
-        self.write_to_file(
-            PathBuf::from("mod.rs"),
-            quote! {
-                include!("macros.rs");
-
-                // Not public as it will only work locally due to needing access to the macros from `macros.rs`.
+                // Not public as it will only work locally due to needing access to the other macros.
+                #[allow(unused_macros)]
                 macro_rules! impl_data_provider {
                     ($provider:ty) => {
                         make_provider!($provider);
@@ -729,8 +698,7 @@ impl DataExporter for BakedExporter {
                     };
                 }
 
-                // Not public because `impl_data_provider` isn't. Users can implement `DynamicDataProvider<AnyMarker>`
-                // using `impl_dynamic_data_provider!`.
+                // Not public because `impl_data_provider` isn't.
                 #[allow(unused_macros)]
                 macro_rules! impl_any_provider {
                     ($provider:ty) => {
@@ -748,20 +716,6 @@ impl DataExporter for BakedExporter {
                         }
                     }
                 }
-
-                // For backwards compatibility
-                #maybe_msrv
-                pub struct BakedDataProvider;
-                impl_data_provider!(BakedDataProvider);
-            },
-        )?;
-
-        // For backwards compatibility
-        self.write_to_file(
-            PathBuf::from("any.rs"),
-            quote! {
-                // This assumes that `mod.rs` is already included.
-                impl_any_provider!(BakedDataProvider);
             },
         )?;
 
@@ -773,20 +727,26 @@ impl DataExporter for BakedExporter {
 
 macro_rules! cb {
     ($($marker:path = $path:literal,)+ #[experimental] $($emarker:path = $epath:literal,)+) => {
-        fn bake_marker(marker: DataMarkerInfo, _env: &databake::CrateEnv) -> databake::TokenStream {
+        fn bake_marker(marker: DataMarkerInfo) -> databake::TokenStream {
             if *marker.path == *icu_provider::hello_world::HelloWorldV1Marker::INFO.path {
                 return databake::quote!(icu_provider::hello_world::HelloWorldV1Marker);
             }
 
             $(
                 if *marker.path == *$path {
-                    return databake::quote!($marker);
+                    return stringify!($marker)
+                        .replace("icu :: ", "icu_")
+                        .parse()
+                        .unwrap();
                 }
             )+
 
             $(
                 if *marker.path == *$epath {
-                    return databake::quote!($emarker);
+                    return stringify!($emarker)
+                        .replace("icu :: ", "icu_")
+                        .parse()
+                        .unwrap();
                 }
             )+
 

provider/baked/tests/data/any.rs

@@ -51,6 +51,8 @@ macro_rules! __impl_core_helloworld_v1 {
         }
     };
 }
+#[doc(inline)]
+pub use __impl_core_helloworld_v1 as impl_core_helloworld_v1;
 /// Implement `IterableDataProvider<HelloWorldV1Marker>` on the given struct using the data
 /// hardcoded in this file. This allows the struct to be used with
 /// `DatagenDriver` for this marker.
@@ -66,3 +68,5 @@ macro_rules! __impliterable_core_helloworld_v1 {
         }
     };
 }
+#[doc(inline)]
+pub use __impliterable_core_helloworld_v1 as impliterable_core_helloworld_v1;