code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/bindgen-0.69.5/ir/comp.rs

@@ -1,1896 +0,0 @@
-//! Compound types (unions and structs) in our intermediate representation.
-
-use itertools::Itertools;
-
-use super::analysis::Sizedness;
-use super::annotations::Annotations;
-use super::context::{BindgenContext, FunctionId, ItemId, TypeId, VarId};
-use super::dot::DotAttributes;
-use super::item::{IsOpaque, Item};
-use super::layout::Layout;
-use super::template::TemplateParameters;
-use super::traversal::{EdgeKind, Trace, Tracer};
-use super::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
-use crate::clang;
-use crate::codegen::struct_layout::{align_to, bytes_from_bits_pow2};
-use crate::ir::derive::CanDeriveCopy;
-use crate::parse::ParseError;
-use crate::HashMap;
-use crate::NonCopyUnionStyle;
-use std::cmp;
-use std::io;
-use std::mem;
-
-/// The kind of compound type.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub(crate) enum CompKind {
-    /// A struct.
-    Struct,
-    /// A union.
-    Union,
-}
-
-/// The kind of C++ method.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub(crate) enum MethodKind {
-    /// A constructor. We represent it as method for convenience, to avoid code
-    /// duplication.
-    Constructor,
-    /// A destructor.
-    Destructor,
-    /// A virtual destructor.
-    VirtualDestructor {
-        /// Whether it's pure virtual.
-        pure_virtual: bool,
-    },
-    /// A static method.
-    Static,
-    /// A normal method.
-    Normal,
-    /// A virtual method.
-    Virtual {
-        /// Whether it's pure virtual.
-        pure_virtual: bool,
-    },
-}
-
-impl MethodKind {
-    /// Is this a destructor method?
-    pub(crate) fn is_destructor(&self) -> bool {
-        matches!(
-            *self,
-            MethodKind::Destructor | MethodKind::VirtualDestructor { .. }
-        )
-    }
-
-    /// Is this a pure virtual method?
-    pub(crate) fn is_pure_virtual(&self) -> bool {
-        match *self {
-            MethodKind::Virtual { pure_virtual } |
-            MethodKind::VirtualDestructor { pure_virtual } => pure_virtual,
-            _ => false,
-        }
-    }
-}
-
-/// A struct representing a C++ method, either static, normal, or virtual.
-#[derive(Debug)]
-pub(crate) struct Method {
-    kind: MethodKind,
-    /// The signature of the method. Take into account this is not a `Type`
-    /// item, but a `Function` one.
-    ///
-    /// This is tricky and probably this field should be renamed.
-    signature: FunctionId,
-    is_const: bool,
-}
-
-impl Method {
-    /// Construct a new `Method`.
-    pub(crate) fn new(
-        kind: MethodKind,
-        signature: FunctionId,
-        is_const: bool,
-    ) -> Self {
-        Method {
-            kind,
-            signature,
-            is_const,
-        }
-    }
-
-    /// What kind of method is this?
-    pub(crate) fn kind(&self) -> MethodKind {
-        self.kind
-    }
-
-    /// Is this a constructor?
-    pub(crate) fn is_constructor(&self) -> bool {
-        self.kind == MethodKind::Constructor
-    }
-
-    /// Is this a virtual method?
-    pub(crate) fn is_virtual(&self) -> bool {
-        matches!(
-            self.kind,
-            MethodKind::Virtual { .. } | MethodKind::VirtualDestructor { .. }
-        )
-    }
-
-    /// Is this a static method?
-    pub(crate) fn is_static(&self) -> bool {
-        self.kind == MethodKind::Static
-    }
-
-    /// Get the ID for the `Function` signature for this method.
-    pub(crate) fn signature(&self) -> FunctionId {
-        self.signature
-    }
-
-    /// Is this a const qualified method?
-    pub(crate) fn is_const(&self) -> bool {
-        self.is_const
-    }
-}
-
-/// Methods common to the various field types.
-pub(crate) trait FieldMethods {
-    /// Get the name of this field.
-    fn name(&self) -> Option<&str>;
-
-    /// Get the type of this field.
-    fn ty(&self) -> TypeId;
-
-    /// Get the comment for this field.
-    fn comment(&self) -> Option<&str>;
-
-    /// If this is a bitfield, how many bits does it need?
-    fn bitfield_width(&self) -> Option<u32>;
-
-    /// Is this feild declared public?
-    fn is_public(&self) -> bool;
-
-    /// Get the annotations for this field.
-    fn annotations(&self) -> &Annotations;
-
-    /// The offset of the field (in bits)
-    fn offset(&self) -> Option<usize>;
-}
-
-/// A contiguous set of logical bitfields that live within the same physical
-/// allocation unit. See 9.2.4 [class.bit] in the C++ standard and [section
-/// 2.4.II.1 in the Itanium C++
-/// ABI](http://itanium-cxx-abi.github.io/cxx-abi/abi.html#class-types).
-#[derive(Debug)]
-pub(crate) struct BitfieldUnit {
-    nth: usize,
-    layout: Layout,
-    bitfields: Vec<Bitfield>,
-}
-
-impl BitfieldUnit {
-    /// Get the 1-based index of this bitfield unit within its containing
-    /// struct. Useful for generating a Rust struct's field name for this unit
-    /// of bitfields.
-    pub(crate) fn nth(&self) -> usize {
-        self.nth
-    }
-
-    /// Get the layout within which these bitfields reside.
-    pub(crate) fn layout(&self) -> Layout {
-        self.layout
-    }
-
-    /// Get the bitfields within this unit.
-    pub(crate) fn bitfields(&self) -> &[Bitfield] {
-        &self.bitfields
-    }
-}
-
-/// A struct representing a C++ field.
-#[derive(Debug)]
-pub(crate) enum Field {
-    /// A normal data member.
-    DataMember(FieldData),
-
-    /// A physical allocation unit containing many logical bitfields.
-    Bitfields(BitfieldUnit),
-}
-
-impl Field {
-    /// Get this field's layout.
-    pub(crate) fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
-        match *self {
-            Field::Bitfields(BitfieldUnit { layout, .. }) => Some(layout),
-            Field::DataMember(ref data) => {
-                ctx.resolve_type(data.ty).layout(ctx)
-            }
-        }
-    }
-}
-
-impl Trace for Field {
-    type Extra = ();
-
-    fn trace<T>(&self, _: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        match *self {
-            Field::DataMember(ref data) => {
-                tracer.visit_kind(data.ty.into(), EdgeKind::Field);
-            }
-            Field::Bitfields(BitfieldUnit { ref bitfields, .. }) => {
-                for bf in bitfields {
-                    tracer.visit_kind(bf.ty().into(), EdgeKind::Field);
-                }
-            }
-        }
-    }
-}
-
-impl DotAttributes for Field {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        match *self {
-            Field::DataMember(ref data) => data.dot_attributes(ctx, out),
-            Field::Bitfields(BitfieldUnit {
-                layout,
-                ref bitfields,
-                ..
-            }) => {
-                writeln!(
-                    out,
-                    r#"<tr>
-                              <td>bitfield unit</td>
-                              <td>
-                                <table border="0">
-                                  <tr>
-                                    <td>unit.size</td><td>{}</td>
-                                  </tr>
-                                  <tr>
-                                    <td>unit.align</td><td>{}</td>
-                                  </tr>
-                         "#,
-                    layout.size, layout.align
-                )?;
-                for bf in bitfields {
-                    bf.dot_attributes(ctx, out)?;
-                }
-                writeln!(out, "</table></td></tr>")
-            }
-        }
-    }
-}
-
-impl DotAttributes for FieldData {
-    fn dot_attributes<W>(
-        &self,
-        _ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(
-            out,
-            "<tr><td>{}</td><td>{:?}</td></tr>",
-            self.name().unwrap_or("(anonymous)"),
-            self.ty()
-        )
-    }
-}
-
-impl DotAttributes for Bitfield {
-    fn dot_attributes<W>(
-        &self,
-        _ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(
-            out,
-            "<tr><td>{} : {}</td><td>{:?}</td></tr>",
-            self.name().unwrap_or("(anonymous)"),
-            self.width(),
-            self.ty()
-        )
-    }
-}
-
-/// A logical bitfield within some physical bitfield allocation unit.
-#[derive(Debug)]
-pub(crate) struct Bitfield {
-    /// Index of the bit within this bitfield's allocation unit where this
-    /// bitfield's bits begin.
-    offset_into_unit: usize,
-
-    /// The field data for this bitfield.
-    data: FieldData,
-
-    /// Name of the generated Rust getter for this bitfield.
-    ///
-    /// Should be assigned before codegen.
-    getter_name: Option<String>,
-
-    /// Name of the generated Rust setter for this bitfield.
-    ///
-    /// Should be assigned before codegen.
-    setter_name: Option<String>,
-}
-
-impl Bitfield {
-    /// Construct a new bitfield.
-    fn new(offset_into_unit: usize, raw: RawField) -> Bitfield {
-        assert!(raw.bitfield_width().is_some());
-
-        Bitfield {
-            offset_into_unit,
-            data: raw.0,
-            getter_name: None,
-            setter_name: None,
-        }
-    }
-
-    /// Get the index of the bit within this bitfield's allocation unit where
-    /// this bitfield begins.
-    pub(crate) fn offset_into_unit(&self) -> usize {
-        self.offset_into_unit
-    }
-
-    /// Get the bit width of this bitfield.
-    pub(crate) fn width(&self) -> u32 {
-        self.data.bitfield_width().unwrap()
-    }
-
-    /// Name of the generated Rust getter for this bitfield.
-    ///
-    /// Panics if called before assigning bitfield accessor names or if
-    /// this bitfield have no name.
-    pub(crate) fn getter_name(&self) -> &str {
-        assert!(
-            self.name().is_some(),
-            "`Bitfield::getter_name` called on anonymous field"
-        );
-        self.getter_name.as_ref().expect(
-            "`Bitfield::getter_name` should only be called after\
-             assigning bitfield accessor names",
-        )
-    }
-
-    /// Name of the generated Rust setter for this bitfield.
-    ///
-    /// Panics if called before assigning bitfield accessor names or if
-    /// this bitfield have no name.
-    pub(crate) fn setter_name(&self) -> &str {
-        assert!(
-            self.name().is_some(),
-            "`Bitfield::setter_name` called on anonymous field"
-        );
-        self.setter_name.as_ref().expect(
-            "`Bitfield::setter_name` should only be called\
-             after assigning bitfield accessor names",
-        )
-    }
-}
-
-impl FieldMethods for Bitfield {
-    fn name(&self) -> Option<&str> {
-        self.data.name()
-    }
-
-    fn ty(&self) -> TypeId {
-        self.data.ty()
-    }
-
-    fn comment(&self) -> Option<&str> {
-        self.data.comment()
-    }
-
-    fn bitfield_width(&self) -> Option<u32> {
-        self.data.bitfield_width()
-    }
-
-    fn is_public(&self) -> bool {
-        self.data.is_public()
-    }
-
-    fn annotations(&self) -> &Annotations {
-        self.data.annotations()
-    }
-
-    fn offset(&self) -> Option<usize> {
-        self.data.offset()
-    }
-}
-
-/// A raw field might be either of a plain data member or a bitfield within a
-/// bitfield allocation unit, but we haven't processed it and determined which
-/// yet (which would involve allocating it into a bitfield unit if it is a
-/// bitfield).
-#[derive(Debug)]
-struct RawField(FieldData);
-
-impl RawField {
-    /// Construct a new `RawField`.
-    fn new(
-        name: Option<String>,
-        ty: TypeId,
-        comment: Option<String>,
-        annotations: Option<Annotations>,
-        bitfield_width: Option<u32>,
-        public: bool,
-        offset: Option<usize>,
-    ) -> RawField {
-        RawField(FieldData {
-            name,
-            ty,
-            comment,
-            annotations: annotations.unwrap_or_default(),
-            bitfield_width,
-            public,
-            offset,
-        })
-    }
-}
-
-impl FieldMethods for RawField {
-    fn name(&self) -> Option<&str> {
-        self.0.name()
-    }
-
-    fn ty(&self) -> TypeId {
-        self.0.ty()
-    }
-
-    fn comment(&self) -> Option<&str> {
-        self.0.comment()
-    }
-
-    fn bitfield_width(&self) -> Option<u32> {
-        self.0.bitfield_width()
-    }
-
-    fn is_public(&self) -> bool {
-        self.0.is_public()
-    }
-
-    fn annotations(&self) -> &Annotations {
-        self.0.annotations()
-    }
-
-    fn offset(&self) -> Option<usize> {
-        self.0.offset()
-    }
-}
-
-/// Convert the given ordered set of raw fields into a list of either plain data
-/// members, and/or bitfield units containing multiple bitfields.
-///
-/// If we do not have the layout for a bitfield's type, then we can't reliably
-/// compute its allocation unit. In such cases, we return an error.
-fn raw_fields_to_fields_and_bitfield_units<I>(
-    ctx: &BindgenContext,
-    raw_fields: I,
-    packed: bool,
-) -> Result<(Vec<Field>, bool), ()>
-where
-    I: IntoIterator<Item = RawField>,
-{
-    let mut raw_fields = raw_fields.into_iter().fuse().peekable();
-    let mut fields = vec![];
-    let mut bitfield_unit_count = 0;
-
-    loop {
-        // While we have plain old data members, just keep adding them to our
-        // resulting fields. We introduce a scope here so that we can use
-        // `raw_fields` again after the `by_ref` iterator adaptor is dropped.
-        {
-            let non_bitfields = raw_fields
-                .by_ref()
-                .peeking_take_while(|f| f.bitfield_width().is_none())
-                .map(|f| Field::DataMember(f.0));
-            fields.extend(non_bitfields);
-        }
-
-        // Now gather all the consecutive bitfields. Only consecutive bitfields
-        // may potentially share a bitfield allocation unit with each other in
-        // the Itanium C++ ABI.
-        let mut bitfields = raw_fields
-            .by_ref()
-            .peeking_take_while(|f| f.bitfield_width().is_some())
-            .peekable();
-
-        if bitfields.peek().is_none() {
-            break;
-        }
-
-        bitfields_to_allocation_units(
-            ctx,
-            &mut bitfield_unit_count,
-            &mut fields,
-            bitfields,
-            packed,
-        )?;
-    }
-
-    assert!(
-        raw_fields.next().is_none(),
-        "The above loop should consume all items in `raw_fields`"
-    );
-
-    Ok((fields, bitfield_unit_count != 0))
-}
-
-/// Given a set of contiguous raw bitfields, group and allocate them into
-/// (potentially multiple) bitfield units.
-fn bitfields_to_allocation_units<E, I>(
-    ctx: &BindgenContext,
-    bitfield_unit_count: &mut usize,
-    fields: &mut E,
-    raw_bitfields: I,
-    packed: bool,
-) -> Result<(), ()>
-where
-    E: Extend<Field>,
-    I: IntoIterator<Item = RawField>,
-{
-    assert!(ctx.collected_typerefs());
-
-    // NOTE: What follows is reverse-engineered from LLVM's
-    // lib/AST/RecordLayoutBuilder.cpp
-    //
-    // FIXME(emilio): There are some differences between Microsoft and the
-    // Itanium ABI, but we'll ignore those and stick to Itanium for now.
-    //
-    // Also, we need to handle packed bitfields and stuff.
-    //
-    // TODO(emilio): Take into account C++'s wide bitfields, and
-    // packing, sigh.
-
-    fn flush_allocation_unit<E>(
-        fields: &mut E,
-        bitfield_unit_count: &mut usize,
-        unit_size_in_bits: usize,
-        unit_align_in_bits: usize,
-        bitfields: Vec<Bitfield>,
-        packed: bool,
-    ) where
-        E: Extend<Field>,
-    {
-        *bitfield_unit_count += 1;
-        let align = if packed {
-            1
-        } else {
-            bytes_from_bits_pow2(unit_align_in_bits)
-        };
-        let size = align_to(unit_size_in_bits, 8) / 8;
-        let layout = Layout::new(size, align);
-        fields.extend(Some(Field::Bitfields(BitfieldUnit {
-            nth: *bitfield_unit_count,
-            layout,
-            bitfields,
-        })));
-    }
-
-    let mut max_align = 0;
-    let mut unfilled_bits_in_unit = 0;
-    let mut unit_size_in_bits = 0;
-    let mut unit_align = 0;
-    let mut bitfields_in_unit = vec![];
-
-    // TODO(emilio): Determine this from attributes or pragma ms_struct
-    // directives. Also, perhaps we should check if the target is MSVC?
-    const is_ms_struct: bool = false;
-
-    for bitfield in raw_bitfields {
-        let bitfield_width = bitfield.bitfield_width().unwrap() as usize;
-        let bitfield_layout =
-            ctx.resolve_type(bitfield.ty()).layout(ctx).ok_or(())?;
-        let bitfield_size = bitfield_layout.size;
-        let bitfield_align = bitfield_layout.align;
-
-        let mut offset = unit_size_in_bits;
-        if !packed {
-            if is_ms_struct {
-                if unit_size_in_bits != 0 &&
-                    (bitfield_width == 0 ||
-                        bitfield_width > unfilled_bits_in_unit)
-                {
-                    // We've reached the end of this allocation unit, so flush it
-                    // and its bitfields.
-                    unit_size_in_bits =
-                        align_to(unit_size_in_bits, unit_align * 8);
-                    flush_allocation_unit(
-                        fields,
-                        bitfield_unit_count,
-                        unit_size_in_bits,
-                        unit_align,
-                        mem::take(&mut bitfields_in_unit),
-                        packed,
-                    );
-
-                    // Now we're working on a fresh bitfield allocation unit, so reset
-                    // the current unit size and alignment.
-                    offset = 0;
-                    unit_align = 0;
-                }
-            } else if offset != 0 &&
-                (bitfield_width == 0 ||
-                    (offset & (bitfield_align * 8 - 1)) + bitfield_width >
-                        bitfield_size * 8)
-            {
-                offset = align_to(offset, bitfield_align * 8);
-            }
-        }
-
-        // According to the x86[-64] ABI spec: "Unnamed bit-fields’ types do not
-        // affect the alignment of a structure or union". This makes sense: such
-        // bit-fields are only used for padding, and we can't perform an
-        // un-aligned read of something we can't read because we can't even name
-        // it.
-        if bitfield.name().is_some() {
-            max_align = cmp::max(max_align, bitfield_align);
-
-            // NB: The `bitfield_width` here is completely, absolutely
-            // intentional.  Alignment of the allocation unit is based on the
-            // maximum bitfield width, not (directly) on the bitfields' types'
-            // alignment.
-            unit_align = cmp::max(unit_align, bitfield_width);
-        }
-
-        // Always keep all bitfields around. While unnamed bitifields are used
-        // for padding (and usually not needed hereafter), large unnamed
-        // bitfields over their types size cause weird allocation size behavior from clang.
-        // Therefore, all bitfields needed to be kept around in order to check for this
-        // and make the struct opaque in this case
-        bitfields_in_unit.push(Bitfield::new(offset, bitfield));
-
-        unit_size_in_bits = offset + bitfield_width;
-
-        // Compute what the physical unit's final size would be given what we
-        // have seen so far, and use that to compute how many bits are still
-        // available in the unit.
-        let data_size = align_to(unit_size_in_bits, bitfield_align * 8);
-        unfilled_bits_in_unit = data_size - unit_size_in_bits;
-    }
-
-    if unit_size_in_bits != 0 {
-        // Flush the last allocation unit and its bitfields.
-        flush_allocation_unit(
-            fields,
-            bitfield_unit_count,
-            unit_size_in_bits,
-            unit_align,
-            bitfields_in_unit,
-            packed,
-        );
-    }
-
-    Ok(())
-}
-
-/// A compound structure's fields are initially raw, and have bitfields that
-/// have not been grouped into allocation units. During this time, the fields
-/// are mutable and we build them up during parsing.
-///
-/// Then, once resolving typerefs is completed, we compute all structs' fields'
-/// bitfield allocation units, and they remain frozen and immutable forever
-/// after.
-#[derive(Debug)]
-enum CompFields {
-    Before(Vec<RawField>),
-    After {
-        fields: Vec<Field>,
-        has_bitfield_units: bool,
-    },
-    Error,
-}
-
-impl Default for CompFields {
-    fn default() -> CompFields {
-        CompFields::Before(vec![])
-    }
-}
-
-impl CompFields {
-    fn append_raw_field(&mut self, raw: RawField) {
-        match *self {
-            CompFields::Before(ref mut raws) => {
-                raws.push(raw);
-            }
-            _ => {
-                panic!(
-                    "Must not append new fields after computing bitfield allocation units"
-                );
-            }
-        }
-    }
-
-    fn compute_bitfield_units(&mut self, ctx: &BindgenContext, packed: bool) {
-        let raws = match *self {
-            CompFields::Before(ref mut raws) => mem::take(raws),
-            _ => {
-                panic!("Already computed bitfield units");
-            }
-        };
-
-        let result = raw_fields_to_fields_and_bitfield_units(ctx, raws, packed);
-
-        match result {
-            Ok((fields, has_bitfield_units)) => {
-                *self = CompFields::After {
-                    fields,
-                    has_bitfield_units,
-                };
-            }
-            Err(()) => {
-                *self = CompFields::Error;
-            }
-        }
-    }
-
-    fn deanonymize_fields(&mut self, ctx: &BindgenContext, methods: &[Method]) {
-        let fields = match *self {
-            CompFields::After { ref mut fields, .. } => fields,
-            // Nothing to do here.
-            CompFields::Error => return,
-            CompFields::Before(_) => {
-                panic!("Not yet computed bitfield units.");
-            }
-        };
-
-        fn has_method(
-            methods: &[Method],
-            ctx: &BindgenContext,
-            name: &str,
-        ) -> bool {
-            methods.iter().any(|method| {
-                let method_name = ctx.resolve_func(method.signature()).name();
-                method_name == name || ctx.rust_mangle(method_name) == name
-            })
-        }
-
-        struct AccessorNamesPair {
-            getter: String,
-            setter: String,
-        }
-
-        let mut accessor_names: HashMap<String, AccessorNamesPair> = fields
-            .iter()
-            .flat_map(|field| match *field {
-                Field::Bitfields(ref bu) => &*bu.bitfields,
-                Field::DataMember(_) => &[],
-            })
-            .filter_map(|bitfield| bitfield.name())
-            .map(|bitfield_name| {
-                let bitfield_name = bitfield_name.to_string();
-                let getter = {
-                    let mut getter =
-                        ctx.rust_mangle(&bitfield_name).to_string();
-                    if has_method(methods, ctx, &getter) {
-                        getter.push_str("_bindgen_bitfield");
-                    }
-                    getter
-                };
-                let setter = {
-                    let setter = format!("set_{}", bitfield_name);
-                    let mut setter = ctx.rust_mangle(&setter).to_string();
-                    if has_method(methods, ctx, &setter) {
-                        setter.push_str("_bindgen_bitfield");
-                    }
-                    setter
-                };
-                (bitfield_name, AccessorNamesPair { getter, setter })
-            })
-            .collect();
-
-        let mut anon_field_counter = 0;
-        for field in fields.iter_mut() {
-            match *field {
-                Field::DataMember(FieldData { ref mut name, .. }) => {
-                    if name.is_some() {
-                        continue;
-                    }
-
-                    anon_field_counter += 1;
-                    *name = Some(format!(
-                        "{}{}",
-                        ctx.options().anon_fields_prefix,
-                        anon_field_counter
-                    ));
-                }
-                Field::Bitfields(ref mut bu) => {
-                    for bitfield in &mut bu.bitfields {
-                        if bitfield.name().is_none() {
-                            continue;
-                        }
-
-                        if let Some(AccessorNamesPair { getter, setter }) =
-                            accessor_names.remove(bitfield.name().unwrap())
-                        {
-                            bitfield.getter_name = Some(getter);
-                            bitfield.setter_name = Some(setter);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl Trace for CompFields {
-    type Extra = ();
-
-    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        match *self {
-            CompFields::Error => {}
-            CompFields::Before(ref fields) => {
-                for f in fields {
-                    tracer.visit_kind(f.ty().into(), EdgeKind::Field);
-                }
-            }
-            CompFields::After { ref fields, .. } => {
-                for f in fields {
-                    f.trace(context, tracer, &());
-                }
-            }
-        }
-    }
-}
-
-/// Common data shared across different field types.
-#[derive(Clone, Debug)]
-pub(crate) struct FieldData {
-    /// The name of the field, empty if it's an unnamed bitfield width.
-    name: Option<String>,
-
-    /// The inner type.
-    ty: TypeId,
-
-    /// The doc comment on the field if any.
-    comment: Option<String>,
-
-    /// Annotations for this field, or the default.
-    annotations: Annotations,
-
-    /// If this field is a bitfield, and how many bits does it contain if it is.
-    bitfield_width: Option<u32>,
-
-    /// If the C++ field is declared `public`
-    public: bool,
-
-    /// The offset of the field (in bits)
-    offset: Option<usize>,
-}
-
-impl FieldMethods for FieldData {
-    fn name(&self) -> Option<&str> {
-        self.name.as_deref()
-    }
-
-    fn ty(&self) -> TypeId {
-        self.ty
-    }
-
-    fn comment(&self) -> Option<&str> {
-        self.comment.as_deref()
-    }
-
-    fn bitfield_width(&self) -> Option<u32> {
-        self.bitfield_width
-    }
-
-    fn is_public(&self) -> bool {
-        self.public
-    }
-
-    fn annotations(&self) -> &Annotations {
-        &self.annotations
-    }
-
-    fn offset(&self) -> Option<usize> {
-        self.offset
-    }
-}
-
-/// The kind of inheritance a base class is using.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum BaseKind {
-    /// Normal inheritance, like:
-    ///
-    /// ```cpp
-    /// class A : public B {};
-    /// ```
-    Normal,
-    /// Virtual inheritance, like:
-    ///
-    /// ```cpp
-    /// class A: public virtual B {};
-    /// ```
-    Virtual,
-}
-
-/// A base class.
-#[derive(Clone, Debug)]
-pub(crate) struct Base {
-    /// The type of this base class.
-    pub(crate) ty: TypeId,
-    /// The kind of inheritance we're doing.
-    pub(crate) kind: BaseKind,
-    /// Name of the field in which this base should be stored.
-    pub(crate) field_name: String,
-    /// Whether this base is inherited from publically.
-    pub(crate) is_pub: bool,
-}
-
-impl Base {
-    /// Whether this base class is inheriting virtually.
-    pub(crate) fn is_virtual(&self) -> bool {
-        self.kind == BaseKind::Virtual
-    }
-
-    /// Whether this base class should have it's own field for storage.
-    pub(crate) fn requires_storage(&self, ctx: &BindgenContext) -> bool {
-        // Virtual bases are already taken into account by the vtable
-        // pointer.
-        //
-        // FIXME(emilio): Is this always right?
-        if self.is_virtual() {
-            return false;
-        }
-
-        // NB: We won't include zero-sized types in our base chain because they
-        // would contribute to our size given the dummy field we insert for
-        // zero-sized types.
-        if self.ty.is_zero_sized(ctx) {
-            return false;
-        }
-
-        true
-    }
-
-    /// Whether this base is inherited from publically.
-    pub(crate) fn is_public(&self) -> bool {
-        self.is_pub
-    }
-}
-
-/// A compound type.
-///
-/// Either a struct or union, a compound type is built up from the combination
-/// of fields which also are associated with their own (potentially compound)
-/// type.
-#[derive(Debug)]
-pub(crate) struct CompInfo {
-    /// Whether this is a struct or a union.
-    kind: CompKind,
-
-    /// The members of this struct or union.
-    fields: CompFields,
-
-    /// The abstract template parameters of this class. Note that these are NOT
-    /// concrete template arguments, and should always be a
-    /// `Type(TypeKind::TypeParam(name))`. For concrete template arguments, see
-    /// `TypeKind::TemplateInstantiation`.
-    template_params: Vec<TypeId>,
-
-    /// The method declarations inside this class, if in C++ mode.
-    methods: Vec<Method>,
-
-    /// The different constructors this struct or class contains.
-    constructors: Vec<FunctionId>,
-
-    /// The destructor of this type. The bool represents whether this destructor
-    /// is virtual.
-    destructor: Option<(MethodKind, FunctionId)>,
-
-    /// Vector of classes this one inherits from.
-    base_members: Vec<Base>,
-
-    /// The inner types that were declared inside this class, in something like:
-    ///
-    /// class Foo {
-    ///     typedef int FooTy;
-    ///     struct Bar {
-    ///         int baz;
-    ///     };
-    /// }
-    ///
-    /// static Foo::Bar const = {3};
-    inner_types: Vec<TypeId>,
-
-    /// Set of static constants declared inside this class.
-    inner_vars: Vec<VarId>,
-
-    /// Whether this type should generate an vtable (TODO: Should be able to
-    /// look at the virtual methods and ditch this field).
-    has_own_virtual_method: bool,
-
-    /// Whether this type has destructor.
-    has_destructor: bool,
-
-    /// Whether this type has a base type with more than one member.
-    ///
-    /// TODO: We should be able to compute this.
-    has_nonempty_base: bool,
-
-    /// If this type has a template parameter which is not a type (e.g.: a
-    /// size_t)
-    has_non_type_template_params: bool,
-
-    /// Whether this type has a bit field member whose width couldn't be
-    /// evaluated (e.g. if it depends on a template parameter). We generate an
-    /// opaque type in this case.
-    has_unevaluable_bit_field_width: bool,
-
-    /// Whether we saw `__attribute__((packed))` on or within this type.
-    packed_attr: bool,
-
-    /// Used to know if we've found an opaque attribute that could cause us to
-    /// generate a type with invalid layout. This is explicitly used to avoid us
-    /// generating bad alignments when parsing types like max_align_t.
-    ///
-    /// It's not clear what the behavior should be here, if generating the item
-    /// and pray, or behave as an opaque type.
-    found_unknown_attr: bool,
-
-    /// Used to indicate when a struct has been forward declared. Usually used
-    /// in headers so that APIs can't modify them directly.
-    is_forward_declaration: bool,
-}
-
-impl CompInfo {
-    /// Construct a new compound type.
-    pub(crate) fn new(kind: CompKind) -> Self {
-        CompInfo {
-            kind,
-            fields: CompFields::default(),
-            template_params: vec![],
-            methods: vec![],
-            constructors: vec![],
-            destructor: None,
-            base_members: vec![],
-            inner_types: vec![],
-            inner_vars: vec![],
-            has_own_virtual_method: false,
-            has_destructor: false,
-            has_nonempty_base: false,
-            has_non_type_template_params: false,
-            has_unevaluable_bit_field_width: false,
-            packed_attr: false,
-            found_unknown_attr: false,
-            is_forward_declaration: false,
-        }
-    }
-
-    /// Compute the layout of this type.
-    ///
-    /// This is called as a fallback under some circumstances where LLVM doesn't
-    /// give us the correct layout.
-    ///
-    /// If we're a union without known layout, we try to compute it from our
-    /// members. This is not ideal, but clang fails to report the size for these
-    /// kind of unions, see test/headers/template_union.hpp
-    pub(crate) fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
-        // We can't do better than clang here, sorry.
-        if self.kind == CompKind::Struct {
-            return None;
-        }
-
-        // By definition, we don't have the right layout information here if
-        // we're a forward declaration.
-        if self.is_forward_declaration() {
-            return None;
-        }
-
-        // empty union case
-        if !self.has_fields() {
-            return None;
-        }
-
-        let mut max_size = 0;
-        // Don't allow align(0)
-        let mut max_align = 1;
-        self.each_known_field_layout(ctx, |layout| {
-            max_size = cmp::max(max_size, layout.size);
-            max_align = cmp::max(max_align, layout.align);
-        });
-
-        Some(Layout::new(max_size, max_align))
-    }
-
-    /// Get this type's set of fields.
-    pub(crate) fn fields(&self) -> &[Field] {
-        match self.fields {
-            CompFields::Error => &[],
-            CompFields::After { ref fields, .. } => fields,
-            CompFields::Before(..) => {
-                panic!("Should always have computed bitfield units first");
-            }
-        }
-    }
-
-    fn has_fields(&self) -> bool {
-        match self.fields {
-            CompFields::Error => false,
-            CompFields::After { ref fields, .. } => !fields.is_empty(),
-            CompFields::Before(ref raw_fields) => !raw_fields.is_empty(),
-        }
-    }
-
-    fn each_known_field_layout(
-        &self,
-        ctx: &BindgenContext,
-        mut callback: impl FnMut(Layout),
-    ) {
-        match self.fields {
-            CompFields::Error => {}
-            CompFields::After { ref fields, .. } => {
-                for field in fields.iter() {
-                    if let Some(layout) = field.layout(ctx) {
-                        callback(layout);
-                    }
-                }
-            }
-            CompFields::Before(ref raw_fields) => {
-                for field in raw_fields.iter() {
-                    let field_ty = ctx.resolve_type(field.0.ty);
-                    if let Some(layout) = field_ty.layout(ctx) {
-                        callback(layout);
-                    }
-                }
-            }
-        }
-    }
-
-    fn has_bitfields(&self) -> bool {
-        match self.fields {
-            CompFields::Error => false,
-            CompFields::After {
-                has_bitfield_units, ..
-            } => has_bitfield_units,
-            CompFields::Before(_) => {
-                panic!("Should always have computed bitfield units first");
-            }
-        }
-    }
-
-    /// Returns whether we have a too large bitfield unit, in which case we may
-    /// not be able to derive some of the things we should be able to normally
-    /// derive.
-    pub(crate) fn has_too_large_bitfield_unit(&self) -> bool {
-        if !self.has_bitfields() {
-            return false;
-        }
-        self.fields().iter().any(|field| match *field {
-            Field::DataMember(..) => false,
-            Field::Bitfields(ref unit) => {
-                unit.layout.size > RUST_DERIVE_IN_ARRAY_LIMIT
-            }
-        })
-    }
-
-    /// Does this type have any template parameters that aren't types
-    /// (e.g. int)?
-    pub(crate) fn has_non_type_template_params(&self) -> bool {
-        self.has_non_type_template_params
-    }
-
-    /// Do we see a virtual function during parsing?
-    /// Get the has_own_virtual_method boolean.
-    pub(crate) fn has_own_virtual_method(&self) -> bool {
-        self.has_own_virtual_method
-    }
-
-    /// Did we see a destructor when parsing this type?
-    pub(crate) fn has_own_destructor(&self) -> bool {
-        self.has_destructor
-    }
-
-    /// Get this type's set of methods.
-    pub(crate) fn methods(&self) -> &[Method] {
-        &self.methods
-    }
-
-    /// Get this type's set of constructors.
-    pub(crate) fn constructors(&self) -> &[FunctionId] {
-        &self.constructors
-    }
-
-    /// Get this type's destructor.
-    pub(crate) fn destructor(&self) -> Option<(MethodKind, FunctionId)> {
-        self.destructor
-    }
-
-    /// What kind of compound type is this?
-    pub(crate) fn kind(&self) -> CompKind {
-        self.kind
-    }
-
-    /// Is this a union?
-    pub(crate) fn is_union(&self) -> bool {
-        self.kind() == CompKind::Union
-    }
-
-    /// The set of types that this one inherits from.
-    pub(crate) fn base_members(&self) -> &[Base] {
-        &self.base_members
-    }
-
-    /// Construct a new compound type from a Clang type.
-    pub(crate) fn from_ty(
-        potential_id: ItemId,
-        ty: &clang::Type,
-        location: Option<clang::Cursor>,
-        ctx: &mut BindgenContext,
-    ) -> Result<Self, ParseError> {
-        use clang_sys::*;
-        assert!(
-            ty.template_args().is_none(),
-            "We handle template instantiations elsewhere"
-        );
-
-        let mut cursor = ty.declaration();
-        let mut kind = Self::kind_from_cursor(&cursor);
-        if kind.is_err() {
-            if let Some(location) = location {
-                kind = Self::kind_from_cursor(&location);
-                cursor = location;
-            }
-        }
-
-        let kind = kind?;
-
-        debug!("CompInfo::from_ty({:?}, {:?})", kind, cursor);
-
-        let mut ci = CompInfo::new(kind);
-        ci.is_forward_declaration =
-            location.map_or(true, |cur| match cur.kind() {
-                CXCursor_ParmDecl => true,
-                CXCursor_StructDecl | CXCursor_UnionDecl |
-                CXCursor_ClassDecl => !cur.is_definition(),
-                _ => false,
-            });
-
-        let mut maybe_anonymous_struct_field = None;
-        cursor.visit(|cur| {
-            if cur.kind() != CXCursor_FieldDecl {
-                if let Some((ty, clang_ty, public, offset)) =
-                    maybe_anonymous_struct_field.take()
-                {
-                    if cur.kind() == CXCursor_TypedefDecl &&
-                        cur.typedef_type().unwrap().canonical_type() ==
-                            clang_ty
-                    {
-                        // Typedefs of anonymous structs appear later in the ast
-                        // than the struct itself, that would otherwise be an
-                        // anonymous field. Detect that case here, and do
-                        // nothing.
-                    } else {
-                        let field = RawField::new(
-                            None, ty, None, None, None, public, offset,
-                        );
-                        ci.fields.append_raw_field(field);
-                    }
-                }
-            }
-
-            match cur.kind() {
-                CXCursor_FieldDecl => {
-                    if let Some((ty, clang_ty, public, offset)) =
-                        maybe_anonymous_struct_field.take()
-                    {
-                        let mut used = false;
-                        cur.visit(|child| {
-                            if child.cur_type() == clang_ty {
-                                used = true;
-                            }
-                            CXChildVisit_Continue
-                        });
-
-                        if !used {
-                            let field = RawField::new(
-                                None, ty, None, None, None, public, offset,
-                            );
-                            ci.fields.append_raw_field(field);
-                        }
-                    }
-
-                    let bit_width = if cur.is_bit_field() {
-                        let width = cur.bit_width();
-
-                        // Make opaque type if the bit width couldn't be
-                        // evaluated.
-                        if width.is_none() {
-                            ci.has_unevaluable_bit_field_width = true;
-                            return CXChildVisit_Break;
-                        }
-
-                        width
-                    } else {
-                        None
-                    };
-
-                    let field_type = Item::from_ty_or_ref(
-                        cur.cur_type(),
-                        cur,
-                        Some(potential_id),
-                        ctx,
-                    );
-
-                    let comment = cur.raw_comment();
-                    let annotations = Annotations::new(&cur);
-                    let name = cur.spelling();
-                    let is_public = cur.public_accessible();
-                    let offset = cur.offset_of_field().ok();
-
-                    // Name can be empty if there are bitfields, for example,
-                    // see tests/headers/struct_with_bitfields.h
-                    assert!(
-                        !name.is_empty() || bit_width.is_some(),
-                        "Empty field name?"
-                    );
-
-                    let name = if name.is_empty() { None } else { Some(name) };
-
-                    let field = RawField::new(
-                        name,
-                        field_type,
-                        comment,
-                        annotations,
-                        bit_width,
-                        is_public,
-                        offset,
-                    );
-                    ci.fields.append_raw_field(field);
-
-                    // No we look for things like attributes and stuff.
-                    cur.visit(|cur| {
-                        if cur.kind() == CXCursor_UnexposedAttr {
-                            ci.found_unknown_attr = true;
-                        }
-                        CXChildVisit_Continue
-                    });
-                }
-                CXCursor_UnexposedAttr => {
-                    ci.found_unknown_attr = true;
-                }
-                CXCursor_EnumDecl |
-                CXCursor_TypeAliasDecl |
-                CXCursor_TypeAliasTemplateDecl |
-                CXCursor_TypedefDecl |
-                CXCursor_StructDecl |
-                CXCursor_UnionDecl |
-                CXCursor_ClassTemplate |
-                CXCursor_ClassDecl => {
-                    // We can find non-semantic children here, clang uses a
-                    // StructDecl to note incomplete structs that haven't been
-                    // forward-declared before, see [1].
-                    //
-                    // Also, clang seems to scope struct definitions inside
-                    // unions, and other named struct definitions inside other
-                    // structs to the whole translation unit.
-                    //
-                    // Let's just assume that if the cursor we've found is a
-                    // definition, it's a valid inner type.
-                    //
-                    // [1]: https://github.com/rust-lang/rust-bindgen/issues/482
-                    let is_inner_struct =
-                        cur.semantic_parent() == cursor || cur.is_definition();
-                    if !is_inner_struct {
-                        return CXChildVisit_Continue;
-                    }
-
-                    // Even if this is a definition, we may not be the semantic
-                    // parent, see #1281.
-                    let inner = Item::parse(cur, Some(potential_id), ctx)
-                        .expect("Inner ClassDecl");
-
-                    // If we avoided recursion parsing this type (in
-                    // `Item::from_ty_with_id()`), then this might not be a
-                    // valid type ID, so check and gracefully handle this.
-                    if ctx.resolve_item_fallible(inner).is_some() {
-                        let inner = inner.expect_type_id(ctx);
-
-                        ci.inner_types.push(inner);
-
-                        // A declaration of an union or a struct without name
-                        // could also be an unnamed field, unfortunately.
-                        if cur.is_anonymous() && cur.kind() != CXCursor_EnumDecl
-                        {
-                            let ty = cur.cur_type();
-                            let public = cur.public_accessible();
-                            let offset = cur.offset_of_field().ok();
-
-                            maybe_anonymous_struct_field =
-                                Some((inner, ty, public, offset));
-                        }
-                    }
-                }
-                CXCursor_PackedAttr => {
-                    ci.packed_attr = true;
-                }
-                CXCursor_TemplateTypeParameter => {
-                    let param = Item::type_param(None, cur, ctx).expect(
-                        "Item::type_param should't fail when pointing \
-                         at a TemplateTypeParameter",
-                    );
-                    ci.template_params.push(param);
-                }
-                CXCursor_CXXBaseSpecifier => {
-                    let is_virtual_base = cur.is_virtual_base();
-                    ci.has_own_virtual_method |= is_virtual_base;
-
-                    let kind = if is_virtual_base {
-                        BaseKind::Virtual
-                    } else {
-                        BaseKind::Normal
-                    };
-
-                    let field_name = match ci.base_members.len() {
-                        0 => "_base".into(),
-                        n => format!("_base_{}", n),
-                    };
-                    let type_id =
-                        Item::from_ty_or_ref(cur.cur_type(), cur, None, ctx);
-                    ci.base_members.push(Base {
-                        ty: type_id,
-                        kind,
-                        field_name,
-                        is_pub: cur.access_specifier() ==
-                            clang_sys::CX_CXXPublic,
-                    });
-                }
-                CXCursor_Constructor | CXCursor_Destructor |
-                CXCursor_CXXMethod => {
-                    let is_virtual = cur.method_is_virtual();
-                    let is_static = cur.method_is_static();
-                    debug_assert!(!(is_static && is_virtual), "How?");
-
-                    ci.has_destructor |= cur.kind() == CXCursor_Destructor;
-                    ci.has_own_virtual_method |= is_virtual;
-
-                    // This used to not be here, but then I tried generating
-                    // stylo bindings with this (without path filters), and
-                    // cried a lot with a method in gfx/Point.h
-                    // (ToUnknownPoint), that somehow was causing the same type
-                    // to be inserted in the map two times.
-                    //
-                    // I couldn't make a reduced test case, but anyway...
-                    // Methods of template functions not only used to be inlined,
-                    // but also instantiated, and we wouldn't be able to call
-                    // them, so just bail out.
-                    if !ci.template_params.is_empty() {
-                        return CXChildVisit_Continue;
-                    }
-
-                    // NB: This gets us an owned `Function`, not a
-                    // `FunctionSig`.
-                    let signature =
-                        match Item::parse(cur, Some(potential_id), ctx) {
-                            Ok(item)
-                                if ctx
-                                    .resolve_item(item)
-                                    .kind()
-                                    .is_function() =>
-                            {
-                                item
-                            }
-                            _ => return CXChildVisit_Continue,
-                        };
-
-                    let signature = signature.expect_function_id(ctx);
-
-                    match cur.kind() {
-                        CXCursor_Constructor => {
-                            ci.constructors.push(signature);
-                        }
-                        CXCursor_Destructor => {
-                            let kind = if is_virtual {
-                                MethodKind::VirtualDestructor {
-                                    pure_virtual: cur.method_is_pure_virtual(),
-                                }
-                            } else {
-                                MethodKind::Destructor
-                            };
-                            ci.destructor = Some((kind, signature));
-                        }
-                        CXCursor_CXXMethod => {
-                            let is_const = cur.method_is_const();
-                            let method_kind = if is_static {
-                                MethodKind::Static
-                            } else if is_virtual {
-                                MethodKind::Virtual {
-                                    pure_virtual: cur.method_is_pure_virtual(),
-                                }
-                            } else {
-                                MethodKind::Normal
-                            };
-
-                            let method =
-                                Method::new(method_kind, signature, is_const);
-
-                            ci.methods.push(method);
-                        }
-                        _ => unreachable!("How can we see this here?"),
-                    }
-                }
-                CXCursor_NonTypeTemplateParameter => {
-                    ci.has_non_type_template_params = true;
-                }
-                CXCursor_VarDecl => {
-                    let linkage = cur.linkage();
-                    if linkage != CXLinkage_External &&
-                        linkage != CXLinkage_UniqueExternal
-                    {
-                        return CXChildVisit_Continue;
-                    }
-
-                    let visibility = cur.visibility();
-                    if visibility != CXVisibility_Default {
-                        return CXChildVisit_Continue;
-                    }
-
-                    if let Ok(item) = Item::parse(cur, Some(potential_id), ctx)
-                    {
-                        ci.inner_vars.push(item.as_var_id_unchecked());
-                    }
-                }
-                // Intentionally not handled
-                CXCursor_CXXAccessSpecifier |
-                CXCursor_CXXFinalAttr |
-                CXCursor_FunctionTemplate |
-                CXCursor_ConversionFunction => {}
-                _ => {
-                    warn!(
-                        "unhandled comp member `{}` (kind {:?}) in `{}` ({})",
-                        cur.spelling(),
-                        clang::kind_to_str(cur.kind()),
-                        cursor.spelling(),
-                        cur.location()
-                    );
-                }
-            }
-            CXChildVisit_Continue
-        });
-
-        if let Some((ty, _, public, offset)) = maybe_anonymous_struct_field {
-            let field =
-                RawField::new(None, ty, None, None, None, public, offset);
-            ci.fields.append_raw_field(field);
-        }
-
-        Ok(ci)
-    }
-
-    fn kind_from_cursor(
-        cursor: &clang::Cursor,
-    ) -> Result<CompKind, ParseError> {
-        use clang_sys::*;
-        Ok(match cursor.kind() {
-            CXCursor_UnionDecl => CompKind::Union,
-            CXCursor_ClassDecl | CXCursor_StructDecl => CompKind::Struct,
-            CXCursor_CXXBaseSpecifier |
-            CXCursor_ClassTemplatePartialSpecialization |
-            CXCursor_ClassTemplate => match cursor.template_kind() {
-                CXCursor_UnionDecl => CompKind::Union,
-                _ => CompKind::Struct,
-            },
-            _ => {
-                warn!("Unknown kind for comp type: {:?}", cursor);
-                return Err(ParseError::Continue);
-            }
-        })
-    }
-
-    /// Get the set of types that were declared within this compound type
-    /// (e.g. nested class definitions).
-    pub(crate) fn inner_types(&self) -> &[TypeId] {
-        &self.inner_types
-    }
-
-    /// Get the set of static variables declared within this compound type.
-    pub(crate) fn inner_vars(&self) -> &[VarId] {
-        &self.inner_vars
-    }
-
-    /// Have we found a field with an opaque type that could potentially mess up
-    /// the layout of this compound type?
-    pub(crate) fn found_unknown_attr(&self) -> bool {
-        self.found_unknown_attr
-    }
-
-    /// Is this compound type packed?
-    pub(crate) fn is_packed(
-        &self,
-        ctx: &BindgenContext,
-        layout: Option<&Layout>,
-    ) -> bool {
-        if self.packed_attr {
-            return true;
-        }
-
-        // Even though `libclang` doesn't expose `#pragma packed(...)`, we can
-        // detect it through its effects.
-        if let Some(parent_layout) = layout {
-            let mut packed = false;
-            self.each_known_field_layout(ctx, |layout| {
-                packed = packed || layout.align > parent_layout.align;
-            });
-            if packed {
-                info!("Found a struct that was defined within `#pragma packed(...)`");
-                return true;
-            }
-
-            if self.has_own_virtual_method && parent_layout.align == 1 {
-                return true;
-            }
-        }
-
-        false
-    }
-
-    /// Return true if a compound type is "naturally packed". This means we can exclude the
-    /// "packed" attribute without changing the layout.
-    /// This is useful for types that need an "align(N)" attribute since rustc won't compile
-    /// structs that have both of those attributes.
-    pub(crate) fn already_packed(&self, ctx: &BindgenContext) -> Option<bool> {
-        let mut total_size: usize = 0;
-
-        for field in self.fields().iter() {
-            let layout = field.layout(ctx)?;
-
-            if layout.align != 0 && total_size % layout.align != 0 {
-                return Some(false);
-            }
-
-            total_size += layout.size;
-        }
-
-        Some(true)
-    }
-
-    /// Returns true if compound type has been forward declared
-    pub(crate) fn is_forward_declaration(&self) -> bool {
-        self.is_forward_declaration
-    }
-
-    /// Compute this compound structure's bitfield allocation units.
-    pub(crate) fn compute_bitfield_units(
-        &mut self,
-        ctx: &BindgenContext,
-        layout: Option<&Layout>,
-    ) {
-        let packed = self.is_packed(ctx, layout);
-        self.fields.compute_bitfield_units(ctx, packed)
-    }
-
-    /// Assign for each anonymous field a generated name.
-    pub(crate) fn deanonymize_fields(&mut self, ctx: &BindgenContext) {
-        self.fields.deanonymize_fields(ctx, &self.methods);
-    }
-
-    /// Returns whether the current union can be represented as a Rust `union`
-    ///
-    /// Requirements:
-    ///     1. Current RustTarget allows for `untagged_union`
-    ///     2. Each field can derive `Copy` or we use ManuallyDrop.
-    ///     3. It's not zero-sized.
-    ///
-    /// Second boolean returns whether all fields can be copied (and thus
-    /// ManuallyDrop is not needed).
-    pub(crate) fn is_rust_union(
-        &self,
-        ctx: &BindgenContext,
-        layout: Option<&Layout>,
-        name: &str,
-    ) -> (bool, bool) {
-        if !self.is_union() {
-            return (false, false);
-        }
-
-        if !ctx.options().untagged_union {
-            return (false, false);
-        }
-
-        if self.is_forward_declaration() {
-            return (false, false);
-        }
-
-        let union_style = if ctx.options().bindgen_wrapper_union.matches(name) {
-            NonCopyUnionStyle::BindgenWrapper
-        } else if ctx.options().manually_drop_union.matches(name) {
-            NonCopyUnionStyle::ManuallyDrop
-        } else {
-            ctx.options().default_non_copy_union_style
-        };
-
-        let all_can_copy = self.fields().iter().all(|f| match *f {
-            Field::DataMember(ref field_data) => {
-                field_data.ty().can_derive_copy(ctx)
-            }
-            Field::Bitfields(_) => true,
-        });
-
-        if !all_can_copy && union_style == NonCopyUnionStyle::BindgenWrapper {
-            return (false, false);
-        }
-
-        if layout.map_or(false, |l| l.size == 0) {
-            return (false, false);
-        }
-
-        (true, all_can_copy)
-    }
-}
-
-impl DotAttributes for CompInfo {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(out, "<tr><td>CompKind</td><td>{:?}</td></tr>", self.kind)?;
-
-        if self.has_own_virtual_method {
-            writeln!(out, "<tr><td>has_vtable</td><td>true</td></tr>")?;
-        }
-
-        if self.has_destructor {
-            writeln!(out, "<tr><td>has_destructor</td><td>true</td></tr>")?;
-        }
-
-        if self.has_nonempty_base {
-            writeln!(out, "<tr><td>has_nonempty_base</td><td>true</td></tr>")?;
-        }
-
-        if self.has_non_type_template_params {
-            writeln!(
-                out,
-                "<tr><td>has_non_type_template_params</td><td>true</td></tr>"
-            )?;
-        }
-
-        if self.packed_attr {
-            writeln!(out, "<tr><td>packed_attr</td><td>true</td></tr>")?;
-        }
-
-        if self.is_forward_declaration {
-            writeln!(
-                out,
-                "<tr><td>is_forward_declaration</td><td>true</td></tr>"
-            )?;
-        }
-
-        if !self.fields().is_empty() {
-            writeln!(out, r#"<tr><td>fields</td><td><table border="0">"#)?;
-            for field in self.fields() {
-                field.dot_attributes(ctx, out)?;
-            }
-            writeln!(out, "</table></td></tr>")?;
-        }
-
-        Ok(())
-    }
-}
-
-impl IsOpaque for CompInfo {
-    type Extra = Option<Layout>;
-
-    fn is_opaque(&self, ctx: &BindgenContext, layout: &Option<Layout>) -> bool {
-        if self.has_non_type_template_params ||
-            self.has_unevaluable_bit_field_width
-        {
-            return true;
-        }
-
-        // When we do not have the layout for a bitfield's type (for example, it
-        // is a type parameter), then we can't compute bitfield units. We are
-        // left with no choice but to make the whole struct opaque, or else we
-        // might generate structs with incorrect sizes and alignments.
-        if let CompFields::Error = self.fields {
-            return true;
-        }
-
-        // Bitfields with a width that is larger than their unit's width have
-        // some strange things going on, and the best we can do is make the
-        // whole struct opaque.
-        if self.fields().iter().any(|f| match *f {
-            Field::DataMember(_) => false,
-            Field::Bitfields(ref unit) => unit.bitfields().iter().any(|bf| {
-                let bitfield_layout = ctx
-                    .resolve_type(bf.ty())
-                    .layout(ctx)
-                    .expect("Bitfield without layout? Gah!");
-                bf.width() / 8 > bitfield_layout.size as u32
-            }),
-        }) {
-            return true;
-        }
-
-        if !ctx.options().rust_features().repr_packed_n {
-            // If we don't have `#[repr(packed(N)]`, the best we can
-            // do is make this struct opaque.
-            //
-            // See https://github.com/rust-lang/rust-bindgen/issues/537 and
-            // https://github.com/rust-lang/rust/issues/33158
-            if self.is_packed(ctx, layout.as_ref()) &&
-                layout.map_or(false, |l| l.align > 1)
-            {
-                warn!("Found a type that is both packed and aligned to greater than \
-                       1; Rust before version 1.33 doesn't have `#[repr(packed(N))]`, so we \
-                       are treating it as opaque. You may wish to set bindgen's rust target \
-                       version to 1.33 or later to enable `#[repr(packed(N))]` support.");
-                return true;
-            }
-        }
-
-        false
-    }
-}
-
-impl TemplateParameters for CompInfo {
-    fn self_template_params(&self, _ctx: &BindgenContext) -> Vec<TypeId> {
-        self.template_params.clone()
-    }
-}
-
-impl Trace for CompInfo {
-    type Extra = Item;
-
-    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, item: &Item)
-    where
-        T: Tracer,
-    {
-        for p in item.all_template_params(context) {
-            tracer.visit_kind(p.into(), EdgeKind::TemplateParameterDefinition);
-        }
-
-        for ty in self.inner_types() {
-            tracer.visit_kind(ty.into(), EdgeKind::InnerType);
-        }
-
-        for &var in self.inner_vars() {
-            tracer.visit_kind(var.into(), EdgeKind::InnerVar);
-        }
-
-        for method in self.methods() {
-            tracer.visit_kind(method.signature.into(), EdgeKind::Method);
-        }
-
-        if let Some((_kind, signature)) = self.destructor() {
-            tracer.visit_kind(signature.into(), EdgeKind::Destructor);
-        }
-
-        for ctor in self.constructors() {
-            tracer.visit_kind(ctor.into(), EdgeKind::Constructor);
-        }
-
-        // Base members and fields are not generated for opaque types (but all
-        // of the above things are) so stop here.
-        if item.is_opaque(context, &()) {
-            return;
-        }
-
-        for base in self.base_members() {
-            tracer.visit_kind(base.ty.into(), EdgeKind::BaseMember);
-        }
-
-        self.fields.trace(context, tracer, &());
-    }
-}