fix(host): fix bitflags

crates/gen-host/src/lib.rs

@@ -8,7 +8,7 @@ use std::{
 use tauri_bindgen_core::{
     uwrite, uwriteln, Files, InterfaceGenerator as _, Source, TypeInfo, Types, WorldGenerator,
 };
-use tauri_bindgen_gen_rust::{FnSig, RustGenerator, TypeMode};
+use tauri_bindgen_gen_rust::{FnSig, RustGenerator, TypeMode, RustFlagsRepr};
 use wit_parser::*;
 
 #[derive(Default, Debug, Clone)]
@@ -213,7 +213,6 @@ impl<'a> InterfaceGenerator<'a> {
             }
 
             uwriteln!(self.src, ");");
-            // uwriteln!(self.src, ").map_err(tauri::InvokeError::from_anyhow);");
 
             if self.gen.opts.async_ {
                 uwriteln!(
@@ -229,48 +228,6 @@ impl<'a> InterfaceGenerator<'a> {
                 ")
             }
 
-            // if self.gen.opts.async_ {
-            //     uwriteln!(self.src, "invoke.resolver.respond_async(async move {{");
-            // } else {
-            //     uwriteln!(self.src, "invoke.resolver.respond({{");
-            // };
-
-            // if func.params.is_empty() {
-            //     let maybe_await = if self.gen.opts.async_ { ".await" } else { "" };
-
-            //     uwriteln!(
-            //         self.src,
-            //         "ctx.{}(){}.map_err(::host::tauri::InvokeError::from_anyhow)",
-            //         func.name.to_snake_case(),
-            //         maybe_await
-            //     );
-            // } else {
-            //     if self.gen.opts.async_ {
-            //         uwriteln!(
-            //             self.src,
-            //             "
-            //             let args = serde_json::from_value(invoke.message.payload().clone())
-            //             .map_err(tauri::InvokeError::from_serde_json)?;"
-            //         );
-            //         uwriteln!(
-            //             self.src,
-            //             "ctx.{}(args).await.map_err(::host::tauri::InvokeError::from_anyhow)",
-            //             func.name.to_snake_case(),
-            //         );
-            //     } else {
-            //         uwriteln!(
-            //             self.src,
-            //             "::host::serde_json::from_value(invoke.message.payload().clone())
-            //                     .map_err(::host::tauri::InvokeError::from_serde_json)
-            //                     .and_then(|args| {{
-            //                         ctx.{}(args).map_err(::host::tauri::InvokeError::from_anyhow)
-            //                     }})
-            //             ",
-            //             func.name.to_snake_case(),
-            //         );
-            //     }
-            // }
-
             uwriteln!(self.src, "}},");
         }
 
@@ -338,32 +295,29 @@ impl<'a> tauri_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
         self.print_typedef_record(id, record, docs, get_serde_attrs);
     }
 
-    fn type_flags(&mut self, _id: TypeId, name: &str, flags: &wit_parser::Flags, docs: &Docs) {
-        self.push_str("host::bitflags! {{\n");
+    fn type_flags(&mut self, id: TypeId, name: &str, flags: &Flags, docs: &Docs) {
+        self.push_str("::tauri_bindgen_host::bitflags::bitflags! {\n");
         self.print_rustdoc(docs);
-        self.push_str(&format!("struct {}: ", name));
 
-        let repr = match flags.repr() {
-            FlagsRepr::U8 => "u8",
-            FlagsRepr::U16 => "u16",
-            FlagsRepr::U32(_) => "u32",
-        };
-        self.push_str(repr);
-        self.push_str(" { \n");
+        let repr = RustFlagsRepr::new(&flags);
+        let info = self.info(id);
 
-        let mut val: u32 = 0;
-        for flag in flags.flags.iter() {
-            self.print_rustdoc(&flag.docs);
-            self.push_str(&format!(
-                "const {} = {:#010b};\n",
-                flag.name.TO_SHOUTY_SNEK_CASE(),
-                val
-            ));
-
-            val = val << 1;
+        if let Some(attrs) = get_serde_attrs(name, self.uses_two_names(&info), info) {
+            self.push_str(&attrs);
         }
 
-        self.push_str("}\n");
+        self.push_str(&format!("pub struct {}: {} {{\n", name.to_upper_camel_case(), repr));
+
+        for (i, flag) in flags.flags.iter().enumerate() {
+            self.print_rustdoc(&flag.docs);      
+            self.src.push_str(&format!(
+                "const {} = 1 << {};\n",
+                flag.name.to_shouty_snake_case(),
+                i,
+            ));
+        }
+
+        self.push_str("}\n}\n");
     }
 
     fn type_tuple(&mut self, id: TypeId, _name: &str, tuple: &wit_parser::Tuple, docs: &Docs) {

crates/gen-rust/src/lib.rs

@@ -1,6 +1,6 @@
 use heck::*;
 use std::collections::HashMap;
-use std::fmt::Write;
+use std::fmt::{Write, self};
 use tauri_bindgen_core::TypeInfo;
 use wit_parser::*;
 
@@ -785,3 +785,36 @@ pub struct FnSig {
     pub self_arg: Option<String>,
     pub self_is_first_param: bool,
 }
+
+pub enum RustFlagsRepr {
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+}
+
+impl RustFlagsRepr {
+    pub fn new(f: &Flags) -> RustFlagsRepr {
+        match f.repr() {
+            FlagsRepr::U8 => RustFlagsRepr::U8,
+            FlagsRepr::U16 => RustFlagsRepr::U16,
+            FlagsRepr::U32(1) => RustFlagsRepr::U32,
+            FlagsRepr::U32(2) => RustFlagsRepr::U64,
+            FlagsRepr::U32(3 | 4) => RustFlagsRepr::U128,
+            FlagsRepr::U32(n) => panic!("unsupported number of flags: {}", n * 32),
+        }
+    }
+}
+
+impl fmt::Display for RustFlagsRepr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RustFlagsRepr::U8 => "u8".fmt(f),
+            RustFlagsRepr::U16 => "u16".fmt(f),
+            RustFlagsRepr::U32 => "u32".fmt(f),
+            RustFlagsRepr::U64 => "u64".fmt(f),
+            RustFlagsRepr::U128 => "u128".fmt(f),
+        }
+    }
+}