Function gen_read_data

rust/fory-derive/src/object/read.rs:132–178

(source_fields: &[SourceField<'_>])

}

pub fn gen_read_data(source_fields: &[SourceField<'_>]) -> TokenStream {
    let fields: Vec<&Field> = source_fields.iter().map(|sf| sf.field).collect();
    // Generate runtime version hash computation that detects enum fields
    let version_hash_ts = gen_struct_version_hash_ts(&fields);
    let read_fields = if source_fields.is_empty() {
        quote! {}
    } else {
        let loop_ts = get_source_fields_loop_ts(source_fields);
        quote! {
            #loop_ts
        }
    };

    let is_tuple = source_fields
        .first()
        .map(|sf| sf.is_tuple_struct)
        .unwrap_or(false);

    // Generate field initializations, sorted by original index for tuple structs
    let mut indexed: Vec<_> = source_fields
        .iter()
        .map(|sf| {
            let private_ident = create_private_field_name(sf.field, sf.original_index);
            let value = quote! { #private_ident };
            (sf.original_index, sf.field_init(value))
        })
        .collect();

    if is_tuple {
        indexed.sort_by_key(|(idx, _)| *idx);
    }

    let field_inits: Vec<_> = indexed.into_iter().map(|(_, ts)| ts).collect();
    let self_construction = crate::util::ok_self_construction(is_tuple, &field_inits);

    quote! {
        // Read and check version hash when class version checking is enabled
        if context.is_check_struct_version() {
            let read_version = context.reader.read_i32()?;
            let type_name = ::std::any::type_name::<Self>();
            let local_version: i32 = #version_hash_ts;
            fory_core::meta::TypeMeta::check_struct_version(read_version, local_version, type_name)?;
        }
        #read_fields
        #self_construction
    }
}

pub fn gen_read(_struct_ident: &Ident) -> TokenStream {
    // Note: We use `Self` instead of `#struct_ident` to correctly handle generic types.