What are the conditions under which box_autoaddoccurs?

[huang12zheng]

It is something about box_autoadd

pub fn inject_enum_SerializeEnum(t: SerializeEnum) {}

generate

#[no_mangle]
pub extern "C" fn new_box_autoadd_serialize_enum_0() -> *mut wire_SerializeEnum {
    support::new_leak_box_ptr(wire_SerializeEnum::new_with_null_ptr())
}

So, What are the conditions under which autoadd occurs?
I guess that as long as there's a struct in the enum there's a struct in the enum?

• some more info

pub enum SerializeEnum {
    Record(Record),
    SerEnum(SerEnum),
}
impl Serialize for SerializeEnum {
    fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            SerializeEnum::Record(ref __field0) => __field0.serialize(__serializer),
            SerializeEnum::SerEnum(ref __field0) => __field0.serialize(__serializer),
        }
    }
}

[fzyzcjy]

Feel free to look at source code and search in it!

flutter_rust_bridge/frb_codegen/src/ir/ty_boxed.rs

Line 22 in 20c5ad5

"autoadd_"

[huang12zheng]

I looked it up here before...But it doesn't look like it.

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<_>>();
        }

For now, I find a new place

fn transform_func_input_add_boxed(input: IrField) -> IrField {
    if input.ty.is_struct() {
        debug!(
            "transform_func_input_add_boxed wrap Boxed to field={:?}",
            input
        );
        IrField {
            ty: Boxed(IrTypeBoxed {
                exist_in_real_api: false, // <--
                inner: Box::new(input.ty.clone()),
            }),
            ..input
        }
    } else {
        input
    }
}

Is this the right place?

[huang12zheng]

Also, I want to say something

is_struct this is not so good, is_need_wrap_box maybe better.
Because this could be a struct or an enum

[fzyzcjy]

Sure, feel free to PR for what you think is better!