Why &mut?

[romamik]

Why does extract_attributes require mutable reference? Maybe I'm using it wrong, but here is an example. This function parses attributes for every field in the structure. I have to do field.clone(). If I make it accept &mut ast, then I cannot keep references for other part of the ast and it becomes unusable.

type FieldDescr<'a, FieldAttr> = (&'a Ident, &'a Type, FieldAttr);

fn extract_fields<FieldAttr: ExtractAttributes<Field>>(
    ast: &DeriveInput,
) -> Result<Vec<FieldDescr<'_, FieldAttr>>> {
    return if let Data::Struct(DataStruct {
        fields: Fields::Named(ref fields),
        ..
    }) = ast.data
    {
        fields
            .named
            .iter()
            .map(|field| {
                let field_name = field.ident.as_ref().expect("expected named field");
                let field_type = &field.ty;
                let field_param = deluxe::extract_attributes::<Field, FieldAttr>(
                    &mut field.clone(),
                )
                .map_err(|e| {
                    Error::new_spanned(field, format!("failed to extract field attributes: {}", e))
                })?;
                Ok((field_name, field_type, field_param))
            })
            .collect::<Result<Vec<_>>>()
    } else {
        return Err(Error::new_spanned(ast, "expected named struct"));
    };
}

[jf2048]

extract_attributes is if you want to remove the matched attributes from the field, mainly this is useful for attribute macros where the extra attributes have to be removed before the token stream is output again or it will cause errors.

In a derive macro you can use parse_attributes which takes a non-mutable reference. You may also be able to get your example to work by using iter_mut over the fields.

[romamik]

Thank you very much for your reply. Actually, I just had to read the documentation further than readme.