Restore manganis optimizations (#3195)

* Create a crate for constant serialization of config structs for manganis
* use SerializeConst for the image asset builder
* switch to a declarative macro for assets
* add serializable options for each asset type
* implement the new manganis macro
* optimize assets in the CLI
* Fix assets with dioxus formattable
* reduce fuzzing test limits
* use the new syntax in examples
* fix avif support
* Fix manganis doc tests
* cache asset optimization
* Split out asset and bundled asset
* make hash pointer width independent
* Fix manganis macro docs
* add constvec::is_empty method to fix clippy lint
* remove nasm feature
* simplify test_rsplit_once test so typos passes
* revert example change from clippy fix
* always accept unix paths
* fix windows path seperator
* fix folder asset hash
* Optimize assets in a blocking task
* Fix asset options docs
* Document Asset and BundledAsset
* simplify the linker macro a bit
* add more docs to AssetParser expansion
* add image format helpers
* Split by  both unix and windows path separators and take the smallest one

packages/manganis/manganis-macro/src/linker.rs

@@ -1,25 +1,33 @@
 use proc_macro2::TokenStream as TokenStream2;
-use serde::Serialize;
+use quote::ToTokens;
 
-/// this new approach will store the assets descriptions *inside the executable*.
-/// The trick is to use the `link_section` attribute.
-/// We force rust to store a json representation of the asset description
+/// We store description of the assets an application uses in the executable.
+/// We use the `link_section` attribute embed an extra section in the executable.
+/// We force rust to store a serialized representation of the asset description
 /// inside a particular region of the binary, with the label "manganis".
-/// After linking, the "manganis" sections of the different executables will be merged.
-pub fn generate_link_section(asset: &impl Serialize) -> TokenStream2 {
+/// After linking, the "manganis" sections of the different object files will be merged.
+pub fn generate_link_section(asset: impl ToTokens) -> TokenStream2 {
     let position = proc_macro2::Span::call_site();
-    let asset_description = serde_json::to_string(asset).unwrap();
-    let len = asset_description.as_bytes().len();
-    let asset_bytes = syn::LitByteStr::new(asset_description.as_bytes(), position);
-    let section_name = syn::LitStr::new(manganis_core::LinkSection::CURRENT.link_section, position);
+    let section_name = syn::LitStr::new(
+        manganis_core::linker::LinkSection::CURRENT.link_section,
+        position,
+    );
 
     quote::quote! {
+        // First serialize the asset into a constant sized buffer
+        const __BUFFER: manganis::macro_helpers::const_serialize::ConstVec<u8> = manganis::macro_helpers::serialize_asset(&#asset);
+        // Then pull out the byte slice
+        const __BYTES: &[u8] = __BUFFER.as_ref();
+        // And the length of the byte slice
+        const __LEN: usize = __BYTES.len();
+
+        // Now that we have the size of the asset, copy the bytes into a static array
         #[link_section = #section_name]
         #[used]
-        static ASSET: [u8; #len] = * #asset_bytes;
+        static __LINK_SECTION: [u8; __LEN] = manganis::macro_helpers::copy_bytes(__BYTES);
 
-        fn __volatile_reader() -> u8 {
-            unsafe { std::ptr::read_volatile(ASSET.as_ptr()) }
+        fn __keep_link_section() -> u8 {
+            unsafe { std::ptr::read_volatile(__LINK_SECTION.as_ptr()) }
         }
     }
 }