fix: compile error when using enum in flutter

libs/flutter_rust_bridge_codegen/src/ir/ty_enum.rs

@@ -0,0 +1,139 @@
+use crate::ir::IrType::{EnumRef, StructRef};
+use crate::ir::*;
+use convert_case::{Case, Casing};
+
+#[derive(Debug, Clone)]
+pub struct IrTypeEnumRef {
+    pub name: String,
+    pub is_struct: bool,
+}
+
+impl IrTypeEnumRef {
+    pub fn get<'a>(&self, file: &'a IrFile) -> &'a IrEnum {
+        &file.enum_pool[&self.name]
+    }
+}
+
+impl IrTypeTrait for IrTypeEnumRef {
+    fn visit_children_types<F: FnMut(&IrType) -> bool>(&self, f: &mut F, ir_file: &IrFile) {
+        let enu = self.get(ir_file);
+        for variant in enu.variants() {
+            if let IrVariantKind::Struct(st) = &variant.kind {
+                st.fields
+                    .iter()
+                    .for_each(|field| field.ty.visit_types(f, ir_file));
+            }
+        }
+    }
+
+    fn safe_ident(&self) -> String {
+        self.dart_api_type().to_case(Case::Snake)
+    }
+    fn dart_api_type(&self) -> String {
+        self.name.to_string()
+    }
+    fn dart_wire_type(&self) -> String {
+        if self.is_struct {
+            self.rust_wire_type()
+        } else {
+            "int".to_owned()
+        }
+    }
+    fn rust_api_type(&self) -> String {
+        self.name.to_string()
+    }
+    fn rust_wire_type(&self) -> String {
+        if self.is_struct {
+            format!("wire_{}", self.name)
+        } else {
+            "i32".to_owned()
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct IrEnum {
+    pub name: String,
+    pub wrapper_name: Option<String>,
+    pub path: Vec<String>,
+    pub comments: Vec<IrComment>,
+    _variants: Vec<IrVariant>,
+    _is_struct: bool,
+}
+
+impl IrEnum {
+    pub fn new(
+        name: String,
+        wrapper_name: Option<String>,
+        path: Vec<String>,
+        comments: Vec<IrComment>,
+        mut variants: Vec<IrVariant>,
+    ) -> Self {
+        fn wrap_box(ty: IrType) -> IrType {
+            match ty {
+                StructRef(_)
+                | EnumRef(IrTypeEnumRef {
+                    is_struct: true, ..
+                }) => IrType::Boxed(IrTypeBoxed {
+                    exist_in_real_api: false,
+                    inner: Box::new(ty),
+                }),
+                _ => ty,
+            }
+        }
+        let _is_struct = variants
+            .iter()
+            .any(|variant| !matches!(variant.kind, IrVariantKind::Value));
+        if _is_struct {
+            variants = variants
+                .into_iter()
+                .map(|variant| IrVariant {
+                    kind: match variant.kind {
+                        IrVariantKind::Struct(st) => IrVariantKind::Struct(IrStruct {
+                            fields: st
+                                .fields
+                                .into_iter()
+                                .map(|field| IrField {
+                                    ty: wrap_box(field.ty),
+                                    ..field
+                                })
+                                .collect(),
+                            ..st
+                        }),
+                        _ => variant.kind,
+                    },
+                    ..variant
+                })
+                .collect::<Vec<_>>();
+        }
+        Self {
+            name,
+            wrapper_name,
+            path,
+            comments,
+            _variants: variants,
+            _is_struct,
+        }
+    }
+
+    pub fn variants(&self) -> &[IrVariant] {
+        &self._variants
+    }
+
+    pub fn is_struct(&self) -> bool {
+        self._is_struct
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct IrVariant {
+    pub name: IrIdent,
+    pub comments: Vec<IrComment>,
+    pub kind: IrVariantKind,
+}
+
+#[derive(Debug, Clone)]
+pub enum IrVariantKind {
+    Value,
+    Struct(IrStruct),
+}