Add a callback to rename field names

[expenses]

I've been using this callback to rename anonymous fields:

#[derive(Debug)]
struct BindgenCallbacks {
    item_replacements: HashMap<&'static str, &'static str>,
    field_name_replacements: HashMap<(&'static str, &'static str), &'static str>,
}

impl BindgenCallbacks {
    fn new() -> Self {
        let mut item_replacements = HashMap::new();
        item_replacements.insert("ResourceDescPacked__bindgen_ty_1", "ResourceBufferImageDescPacked");
        item_replacements.insert("ResourceDescPacked__bindgen_ty_1__bindgen_ty_1", "ResourceImageDescPacked");
        item_replacements.insert("ResourceDescPacked__bindgen_ty_1__bindgen_ty_2", "ResourceBufferDescPacked");
        item_replacements.insert("ResourceDescPacked__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1", "ResourceImageDepthArrayLayersDescPacked");
    
        let mut field_name_replacements = HashMap::new();
    
        field_name_replacements.insert(("ResourceDescPacked", "__bindgen_anon_1"), "buffer_image");
        field_name_replacements.insert(("ResourceImageDescPacked", "__bindgen_anon_1"), "depth_array_layers");

        Self {
            item_replacements, field_name_replacements
        }
    }
}

impl bindgen::callbacks::ParseCallbacks for BindgenCallbacks {
    fn process_field_name(&self, parent_name: &str, name: &str) -> Option<String> {
        if let Some(&replacement) = self.field_name_replacements.get(&(parent_name, name)) {
            Some(String::from(replacement))
        } else {
            None
        }
    }
    
    ...
}

Source struct (from https://github.com/GPUOpen-LibrariesAndSDKs/RenderPipelineShaders):

struct ResourceDescPacked
    {
        RpsResourceType  type : 8;            ///< An enumeration indicating the type (and dimension) of the resource.
        uint32_t         temporalLayers : 8;  ///< The number of frames of temporal data.
        RpsResourceFlags flags : 16;          ///< A collection of <c><i>RpsResourceFlagBits</i></c> values.

        union
        {
            struct
            {
                uint32_t width;   ///< The width of an image, or low 32 bit of the byte size of a buffer.
                uint32_t height;  ///< The height of an image, or high 32 bit of the byte size of a buffer.
                union
                {
                    uint32_t depth;        ///< The depth of an 3D image.
                    uint32_t arrayLayers;  ///< The number of array layers for an non-3D image.
                };
                uint32_t  mipLevels : 8;    ///< The number of mipmap levels.
                RpsFormat format : 8;       ///< A platform independent format to be interepreted by the runtime.
                uint32_t  sampleCount : 8;  ///< The number of MSAA samples of an image.
            } image;
            struct
            {
                uint32_t sizeInBytesLo;
                uint32_t sizeInBytesHi;
            } buffer;
        };
}

I'm not sure whether this is implemented in the best way. Very happy to make changes.

[bors-servo]

☔ The latest upstream changes (presumably 4faa366) made this pull request unmergeable. Please resolve the merge conflicts.

[tgross35]

Could you specify what parent_name is? Assuming it's the struct type, something like type_name may be better, since usually parent/child refer to nested types or modules (rather than fields).

[tgross35]

Suggested change

	.map(|name| Cow::Owned(name))
	.map(Cow::Owned)

[tgross35]

Clippy says

this expression creates a reference which is immediately dereferenced by the compiler

can you remove the &? (not sure which one or both)

[tgross35]

Suggested change

	.unwrap_or(name.to_owned())
	.unwrap_or(name.into_owned())

Per clippy

this to_owned call clones the Cow<', str> itself and does not cause the Cow<', str> contents to become owned