Adding upstream version 0.26.0.upstream/0.26.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

41 files changed, 13492 insertions, 0 deletions

diff --git a/src/bindgen/bindings.rs b/src/bindgen/bindings.rs
new file mode 100644
index 0000000..410b11f
--- /dev/null
+++ b/src/bindgen/bindings.rs
@@ -0,0 +1,537 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::borrow::Cow;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::fs;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path;
+use std::rc::Rc;
+
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::ir::{
+    Constant, Function, ItemContainer, ItemMap, Path as BindgenPath, Static, Struct, Typedef,
+};
+use crate::bindgen::writer::{Source, SourceWriter};
+
+/// A bindings header that can be written.
+pub struct Bindings {
+    pub config: Config,
+    /// The map from path to struct, used to lookup whether a given type is a
+    /// transparent struct. This is needed to generate code for constants.
+    struct_map: ItemMap<Struct>,
+    typedef_map: ItemMap<Typedef>,
+    struct_fileds_memo: RefCell<HashMap<BindgenPath, Rc<Vec<String>>>>,
+    globals: Vec<Static>,
+    constants: Vec<Constant>,
+    items: Vec<ItemContainer>,
+    functions: Vec<Function>,
+    source_files: Vec<path::PathBuf>,
+    /// Bindings are generated by a recursive call to cbindgen
+    /// and shouldn't do anything when written anywhere.
+    noop: bool,
+}
+
+#[derive(PartialEq, Eq)]
+enum NamespaceOperation {
+    Open,
+    Close,
+}
+
+impl Bindings {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new(
+        config: Config,
+        struct_map: ItemMap<Struct>,
+        typedef_map: ItemMap<Typedef>,
+        constants: Vec<Constant>,
+        globals: Vec<Static>,
+        items: Vec<ItemContainer>,
+        functions: Vec<Function>,
+        source_files: Vec<path::PathBuf>,
+        noop: bool,
+    ) -> Bindings {
+        Bindings {
+            config,
+            struct_map,
+            typedef_map,
+            struct_fileds_memo: Default::default(),
+            globals,
+            constants,
+            items,
+            functions,
+            source_files,
+            noop,
+        }
+    }
+
+    // FIXME(emilio): What to do when the configuration doesn't match?
+    pub fn struct_is_transparent(&self, path: &BindgenPath) -> bool {
+        let mut any = false;
+        self.struct_map.for_items(path, |s| any |= s.is_transparent);
+        any
+    }
+
+    /// Peels through typedefs to allow resolving structs.
+    fn resolved_struct_path<'a>(&self, path: &'a BindgenPath) -> Cow<'a, BindgenPath> {
+        use crate::bindgen::ir::Type;
+
+        let mut resolved_path = Cow::Borrowed(path);
+        loop {
+            let mut found = None;
+            self.typedef_map.for_items(&resolved_path, |item| {
+                if let Type::Path(ref p) = item.aliased {
+                    found = Some(p.path().clone());
+                }
+            });
+            resolved_path = match found {
+                Some(p) => Cow::Owned(p),
+                None => break,
+            }
+        }
+        resolved_path
+    }
+
+    pub fn struct_exists(&self, path: &BindgenPath) -> bool {
+        let mut any = false;
+        self.struct_map
+            .for_items(&self.resolved_struct_path(path), |_| any = true);
+        any
+    }
+
+    pub fn struct_field_names(&self, path: &BindgenPath) -> Rc<Vec<String>> {
+        let mut memos = self.struct_fileds_memo.borrow_mut();
+        if let Some(memo) = memos.get(path) {
+            return memo.clone();
+        }
+
+        let resolved_path = self.resolved_struct_path(path);
+
+        let mut fields = Vec::<String>::new();
+        self.struct_map.for_items(&resolved_path, |st| {
+            let mut pos: usize = 0;
+            for field in &st.fields {
+                if let Some(found_pos) = fields.iter().position(|v| *v == field.name) {
+                    pos = found_pos + 1;
+                } else {
+                    fields.insert(pos, field.name.clone());
+                    pos += 1;
+                }
+            }
+        });
+
+        let fields = Rc::new(fields);
+        memos.insert(path.clone(), fields.clone());
+        if let Cow::Owned(p) = resolved_path {
+            memos.insert(p, fields.clone());
+        }
+        fields
+    }
+
+    pub fn generate_depfile<P: AsRef<path::Path>>(&self, header_path: P, depfile_path: P) {
+        if let Some(dir) = depfile_path.as_ref().parent() {
+            if !dir.exists() {
+                std::fs::create_dir_all(dir).unwrap()
+            }
+        }
+        let canon_header_path = header_path.as_ref().canonicalize().unwrap();
+        let mut canon_source_files: Vec<_> = self
+            .source_files
+            .iter()
+            .chain(self.config.config_path.as_ref())
+            .map(|p| p.canonicalize().unwrap())
+            .collect();
+        // Sorting makes testing easier by ensuring the output is ordered.
+        canon_source_files.sort_unstable();
+
+        // When writing the depfile we must escape whitespace in paths to avoid it being interpreted
+        // as a seperator.
+        // It is not clear how to otherwise _correctly_ replace whitespace in a non-unicode
+        // compliant slice, without knowing the encoding, so we lossy convert such cases,
+        // to avoid panics.
+        let mut depfile = File::create(depfile_path).unwrap();
+        write!(
+            &mut depfile,
+            "{}:",
+            canon_header_path.to_string_lossy().replace(' ', "\\ ")
+        )
+        .expect("Writing header name to depfile failed");
+        canon_source_files.into_iter().for_each(|source_file| {
+            // Add line-continue and line-break and then indent with 4 spaces.
+            // This makes the output more human-readable.
+            depfile.write_all(b" \\\n    ").unwrap();
+            let escaped_path = source_file.to_string_lossy().replace(' ', "\\ ");
+            depfile.write_all(escaped_path.as_bytes()).unwrap();
+        });
+
+        writeln!(&mut depfile).unwrap();
+
+        depfile.flush().unwrap();
+    }
+
+    pub fn write_to_file<P: AsRef<path::Path>>(&self, path: P) -> bool {
+        if self.noop {
+            return false;
+        }
+
+        // Don't compare files if we've never written this file before
+        if !path.as_ref().is_file() {
+            if let Some(parent) = path::Path::new(path.as_ref()).parent() {
+                fs::create_dir_all(parent).unwrap();
+            }
+            self.write(File::create(path).unwrap());
+            return true;
+        }
+
+        let mut new_file_contents = Vec::new();
+        self.write(&mut new_file_contents);
+
+        let mut old_file_contents = Vec::new();
+        {
+            let mut old_file = File::open(&path).unwrap();
+            old_file.read_to_end(&mut old_file_contents).unwrap();
+        }
+
+        if old_file_contents != new_file_contents {
+            let mut new_file = File::create(&path).unwrap();
+            new_file.write_all(&new_file_contents).unwrap();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn write_headers<F: Write>(&self, out: &mut SourceWriter<F>) {
+        if self.noop {
+            return;
+        }
+
+        if let Some(ref f) = self.config.header {
+            out.new_line_if_not_start();
+            write!(out, "{}", f);
+            out.new_line();
+        }
+        if let Some(f) = self.config.include_guard() {
+            out.new_line_if_not_start();
+            write!(out, "#ifndef {}", f);
+            out.new_line();
+            write!(out, "#define {}", f);
+            out.new_line();
+        }
+        if self.config.pragma_once && self.config.language != Language::Cython {
+            out.new_line_if_not_start();
+            write!(out, "#pragma once");
+            out.new_line();
+        }
+        if self.config.include_version {
+            out.new_line_if_not_start();
+            write!(
+                out,
+                "/* Generated with cbindgen:{} */",
+                crate::bindgen::config::VERSION
+            );
+            out.new_line();
+        }
+        if let Some(ref f) = self.config.autogen_warning {
+            out.new_line_if_not_start();
+            write!(out, "{}", f);
+            out.new_line();
+        }
+
+        if self.config.no_includes
+            && self.config.sys_includes().is_empty()
+            && self.config.includes().is_empty()
+            && (self.config.cython.cimports.is_empty() || self.config.language != Language::Cython)
+            && self.config.after_includes.is_none()
+        {
+            return;
+        }
+
+        out.new_line_if_not_start();
+
+        if !self.config.no_includes {
+            match self.config.language {
+                Language::C => {
+                    out.write("#include <stdarg.h>");
+                    out.new_line();
+                    out.write("#include <stdbool.h>");
+                    out.new_line();
+                    if self.config.usize_is_size_t {
+                        out.write("#include <stddef.h>");
+                        out.new_line();
+                    }
+                    out.write("#include <stdint.h>");
+                    out.new_line();
+                    out.write("#include <stdlib.h>");
+                    out.new_line();
+                }
+                Language::Cxx => {
+                    out.write("#include <cstdarg>");
+                    out.new_line();
+                    if self.config.usize_is_size_t {
+                        out.write("#include <cstddef>");
+                        out.new_line();
+                    }
+                    out.write("#include <cstdint>");
+                    out.new_line();
+                    out.write("#include <cstdlib>");
+                    out.new_line();
+                    out.write("#include <ostream>");
+                    out.new_line();
+                    out.write("#include <new>");
+                    out.new_line();
+                    if self.config.enumeration.cast_assert_name.is_none()
+                        && (self.config.enumeration.derive_mut_casts
+                            || self.config.enumeration.derive_const_casts)
+                    {
+                        out.write("#include <cassert>");
+                        out.new_line();
+                    }
+                }
+                Language::Cython => {
+                    out.write(
+                        "from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t",
+                    );
+                    out.new_line();
+                    out.write(
+                        "from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t",
+                    );
+                    out.new_line();
+                    out.write("cdef extern from *");
+                    out.open_brace();
+                    out.write("ctypedef bint bool");
+                    out.new_line();
+                    out.write("ctypedef struct va_list");
+                    out.new_line();
+                    out.close_brace(false);
+                }
+            }
+        }
+
+        for include in self.config.sys_includes() {
+            write!(out, "#include <{}>", include);
+            out.new_line();
+        }
+
+        for include in self.config.includes() {
+            write!(out, "#include \"{}\"", include);
+            out.new_line();
+        }
+
+        if self.config.language == Language::Cython {
+            for (module, names) in &self.config.cython.cimports {
+                write!(out, "from {} cimport {}", module, names.join(", "));
+                out.new_line();
+            }
+        }
+
+        if let Some(ref line) = self.config.after_includes {
+            write!(out, "{}", line);
+            out.new_line();
+        }
+    }
+
+    pub fn write<F: Write>(&self, file: F) {
+        if self.noop {
+            return;
+        }
+
+        let mut out = SourceWriter::new(file, self);
+
+        self.write_headers(&mut out);
+
+        self.open_namespaces(&mut out);
+
+        for constant in &self.constants {
+            if constant.uses_only_primitive_types() {
+                out.new_line_if_not_start();
+                constant.write(&self.config, &mut out, None);
+                out.new_line();
+            }
+        }
+
+        for item in &self.items {
+            if item
+                .deref()
+                .annotations()
+                .bool("no-export")
+                .unwrap_or(false)
+            {
+                continue;
+            }
+
+            out.new_line_if_not_start();
+            match *item {
+                ItemContainer::Constant(..) => unreachable!(),
+                ItemContainer::Static(..) => unreachable!(),
+                ItemContainer::Enum(ref x) => x.write(&self.config, &mut out),
+                ItemContainer::Struct(ref x) => x.write(&self.config, &mut out),
+                ItemContainer::Union(ref x) => x.write(&self.config, &mut out),
+                ItemContainer::OpaqueItem(ref x) => x.write(&self.config, &mut out),
+                ItemContainer::Typedef(ref x) => x.write(&self.config, &mut out),
+            }
+            out.new_line();
+        }
+
+        for constant in &self.constants {
+            if !constant.uses_only_primitive_types() {
+                out.new_line_if_not_start();
+                constant.write(&self.config, &mut out, None);
+                out.new_line();
+            }
+        }
+
+        if !self.functions.is_empty() || !self.globals.is_empty() {
+            if self.config.cpp_compatible_c() {
+                out.new_line_if_not_start();
+                out.write("#ifdef __cplusplus");
+            }
+
+            if self.config.language == Language::Cxx {
+                if let Some(ref using_namespaces) = self.config.using_namespaces {
+                    for namespace in using_namespaces {
+                        out.new_line();
+                        write!(out, "using namespace {};", namespace);
+                    }
+                    out.new_line();
+                }
+            }
+
+            if self.config.language == Language::Cxx || self.config.cpp_compatible_c() {
+                out.new_line();
+                out.write("extern \"C\" {");
+                out.new_line();
+            }
+
+            if self.config.cpp_compatible_c() {
+                out.write("#endif // __cplusplus");
+                out.new_line();
+            }
+
+            for global in &self.globals {
+                out.new_line_if_not_start();
+                global.write(&self.config, &mut out);
+                out.new_line();
+            }
+
+            for function in &self.functions {
+                out.new_line_if_not_start();
+                function.write(&self.config, &mut out);
+                out.new_line();
+            }
+
+            if self.config.cpp_compatible_c() {
+                out.new_line();
+                out.write("#ifdef __cplusplus");
+            }
+
+            if self.config.language == Language::Cxx || self.config.cpp_compatible_c() {
+                out.new_line();
+                out.write("} // extern \"C\"");
+                out.new_line();
+            }
+
+            if self.config.cpp_compatible_c() {
+                out.write("#endif // __cplusplus");
+                out.new_line();
+            }
+        }
+
+        if self.config.language == Language::Cython
+            && self.globals.is_empty()
+            && self.constants.is_empty()
+            && self.items.is_empty()
+            && self.functions.is_empty()
+        {
+            out.write("pass");
+        }
+
+        self.close_namespaces(&mut out);
+
+        if let Some(f) = self.config.include_guard() {
+            out.new_line_if_not_start();
+            if self.config.language == Language::C {
+                write!(out, "#endif /* {} */", f);
+            } else {
+                write!(out, "#endif // {}", f);
+            }
+            out.new_line();
+        }
+        if let Some(ref f) = self.config.trailer {
+            out.new_line_if_not_start();
+            write!(out, "{}", f);
+            if !f.ends_with('\n') {
+                out.new_line();
+            }
+        }
+    }
+
+    fn all_namespaces(&self) -> Vec<&str> {
+        if self.config.language != Language::Cxx && !self.config.cpp_compatible_c() {
+            return vec![];
+        }
+        let mut ret = vec![];
+        if let Some(ref namespace) = self.config.namespace {
+            ret.push(&**namespace);
+        }
+        if let Some(ref namespaces) = self.config.namespaces {
+            for namespace in namespaces {
+                ret.push(&**namespace);
+            }
+        }
+        ret
+    }
+
+    fn open_close_namespaces<F: Write>(&self, op: NamespaceOperation, out: &mut SourceWriter<F>) {
+        if self.config.language == Language::Cython {
+            if op == NamespaceOperation::Open {
+                out.new_line();
+                let header = self.config.cython.header.as_deref().unwrap_or("*");
+                write!(out, "cdef extern from {}", header);
+                out.open_brace();
+            } else {
+                out.close_brace(false);
+            }
+            return;
+        }
+
+        let mut namespaces = self.all_namespaces();
+        if namespaces.is_empty() {
+            return;
+        }
+
+        if op == NamespaceOperation::Close {
+            namespaces.reverse();
+        }
+
+        if self.config.cpp_compatible_c() {
+            out.new_line_if_not_start();
+            out.write("#ifdef __cplusplus");
+        }
+
+        for namespace in namespaces {
+            out.new_line();
+            match op {
+                NamespaceOperation::Open => write!(out, "namespace {} {{", namespace),
+                NamespaceOperation::Close => write!(out, "}} // namespace {}", namespace),
+            }
+        }
+
+        out.new_line();
+        if self.config.cpp_compatible_c() {
+            out.write("#endif // __cplusplus");
+            out.new_line();
+        }
+    }
+
+    pub(crate) fn open_namespaces<F: Write>(&self, out: &mut SourceWriter<F>) {
+        self.open_close_namespaces(NamespaceOperation::Open, out);
+    }
+
+    pub(crate) fn close_namespaces<F: Write>(&self, out: &mut SourceWriter<F>) {
+        self.open_close_namespaces(NamespaceOperation::Close, out);
+    }
+}
diff --git a/src/bindgen/bitflags.rs b/src/bindgen/bitflags.rs
new file mode 100644
index 0000000..2ca0be6
--- /dev/null
+++ b/src/bindgen/bitflags.rs
@@ -0,0 +1,289 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use proc_macro2::TokenStream;
+use std::collections::HashSet;
+use syn::fold::Fold;
+use syn::parse::{Parse, ParseStream, Parser, Result as ParseResult};
+
+// $(#[$outer:meta])*
+// ($($vis:tt)*) $BitFlags:ident: $T:ty {
+//     $(
+//         $(#[$inner:ident $($args:tt)*])*
+//         const $Flag:ident = $value:expr;
+//     )+
+// }
+#[derive(Debug)]
+pub struct BitflagsStruct {
+    attrs: Vec<syn::Attribute>,
+    vis: syn::Visibility,
+    #[allow(dead_code)]
+    struct_token: Token![struct],
+    name: syn::Ident,
+    #[allow(dead_code)]
+    colon_token: Token![:],
+    repr: syn::Type,
+    flags: Flags,
+}
+
+// impl $BitFlags:ident: $T:ty {
+//     $(
+//         $(#[$inner:ident $($args:tt)*])*
+//         const $Flag:ident = $value:expr;
+//     )+
+// }
+#[derive(Debug)]
+pub struct BitflagsImpl {
+    #[allow(dead_code)]
+    impl_token: Token![impl],
+    name: syn::Ident,
+    #[allow(dead_code)]
+    colon_token: Token![:],
+    repr: syn::Type,
+    flags: Flags,
+}
+
+#[derive(Debug)]
+pub enum Bitflags {
+    Struct(BitflagsStruct),
+    Impl(BitflagsImpl),
+}
+
+impl Bitflags {
+    pub fn expand(&self) -> (Option<syn::ItemStruct>, syn::ItemImpl) {
+        match self {
+            Bitflags::Struct(BitflagsStruct {
+                attrs,
+                vis,
+                name,
+                repr,
+                flags,
+                ..
+            }) => {
+                let struct_ = parse_quote! {
+                    #(#attrs)*
+                    #vis struct #name {
+                        bits: #repr,
+                    }
+                };
+
+                let consts = flags.expand(name, repr, false);
+                let impl_ = parse_quote! {
+                    impl #name {
+                        #consts
+                    }
+                };
+
+                (Some(struct_), impl_)
+            }
+            Bitflags::Impl(BitflagsImpl {
+                name, repr, flags, ..
+            }) => {
+                let consts = flags.expand(name, repr, true);
+                let impl_: syn::ItemImpl = parse_quote! {
+                    impl #name {
+                        #consts
+                    }
+                };
+                (None, impl_)
+            }
+        }
+    }
+}
+
+impl Parse for Bitflags {
+    fn parse(input: ParseStream) -> ParseResult<Self> {
+        Ok(if input.peek(Token![impl]) {
+            Self::Impl(BitflagsImpl {
+                impl_token: input.parse()?,
+                name: input.parse()?,
+                colon_token: input.parse()?,
+                repr: input.parse()?,
+                flags: input.parse()?,
+            })
+        } else {
+            Self::Struct(BitflagsStruct {
+                attrs: input.call(syn::Attribute::parse_outer)?,
+                vis: input.parse()?,
+                struct_token: input.parse()?,
+                name: input.parse()?,
+                colon_token: input.parse()?,
+                repr: input.parse()?,
+                flags: input.parse()?,
+            })
+        })
+    }
+}
+
+// $(#[$inner:ident $($args:tt)*])*
+// const $Flag:ident = $value:expr;
+#[derive(Debug)]
+struct Flag {
+    attrs: Vec<syn::Attribute>,
+    #[allow(dead_code)]
+    const_token: Token![const],
+    name: syn::Ident,
+    #[allow(dead_code)]
+    equals_token: Token![=],
+    value: syn::Expr,
+    #[allow(dead_code)]
+    semicolon_token: Token![;],
+}
+
+struct FlagValueFold<'a> {
+    struct_name: &'a syn::Ident,
+    flag_names: &'a HashSet<String>,
+    out_of_line: bool,
+}
+
+impl<'a> FlagValueFold<'a> {
+    fn is_self(&self, ident: &syn::Ident) -> bool {
+        ident == self.struct_name || ident == "Self"
+    }
+}
+
+impl<'a> Fold for FlagValueFold<'a> {
+    fn fold_expr(&mut self, node: syn::Expr) -> syn::Expr {
+        // bitflags 2 doesn't expose `bits` publically anymore, and the documented way to
+        // combine flags is using the `bits` method, e.g.
+        // ```
+        // bitflags! {
+        //     struct Flags: u8 {
+        //         const A = 1;
+        //         const B = 1 << 1;
+        //         const AB = Flags::A.bits() | Flags::B.bits();
+        //     }
+        // }
+        // ```
+        // As we're transforming the struct definition into `struct StructName { bits: T }`
+        // as far as our bindings generation is concerned, `bits` is available as a field,
+        // so by replacing `StructName::FLAG.bits()` with `StructName::FLAG.bits`, we make
+        // e.g. `Flags::AB` available in the generated bindings.
+        // For out-of-line definitions of the struct(*), where the struct is defined as a
+        // newtype, we replace it with `StructName::FLAGS.0`.
+        // * definitions like:
+        // ```
+        // struct Flags(u8);
+        // bitflags! {
+        //    impl Flags: u8 {
+        //         const A = 1;
+        //         const B = 1 << 1;
+        //         const AB = Flags::A.bits() | Flags::B.bits();
+        //     }
+        // }
+        // ```
+        match node {
+            syn::Expr::MethodCall(syn::ExprMethodCall {
+                attrs,
+                receiver,
+                dot_token,
+                method,
+                args,
+                ..
+            }) if method == "bits"
+                && args.is_empty()
+                && matches!(&*receiver,
+                syn::Expr::Path(syn::ExprPath { path, .. })
+                    if path.segments.len() == 2
+                        && self.is_self(&path.segments.first().unwrap().ident)
+                        && self
+                            .flag_names
+                            .contains(&path.segments.last().unwrap().ident.to_string())) =>
+            {
+                return syn::Expr::Field(syn::ExprField {
+                    attrs,
+                    base: receiver,
+                    dot_token,
+                    member: if self.out_of_line {
+                        syn::Member::Unnamed(parse_quote! {0})
+                    } else {
+                        syn::Member::Named(method)
+                    },
+                });
+            }
+            _ => {}
+        }
+        syn::fold::fold_expr(self, node)
+    }
+}
+
+impl Flag {
+    fn expand(
+        &self,
+        struct_name: &syn::Ident,
+        repr: &syn::Type,
+        flag_names: &HashSet<String>,
+        out_of_line: bool,
+    ) -> TokenStream {
+        let Flag {
+            ref attrs,
+            ref name,
+            ref value,
+            ..
+        } = *self;
+        let folded_value = FlagValueFold {
+            struct_name,
+            flag_names,
+            out_of_line,
+        }
+        .fold_expr(value.clone());
+        let value = if out_of_line {
+            quote! { ((#folded_value) as #repr) }
+        } else {
+            quote! { { bits: (#folded_value) as #repr } }
+        };
+        quote! {
+            #(#attrs)*
+            pub const #name : #struct_name = #struct_name #value;
+        }
+    }
+}
+
+impl Parse for Flag {
+    fn parse(input: ParseStream) -> ParseResult<Self> {
+        Ok(Self {
+            attrs: input.call(syn::Attribute::parse_outer)?,
+            const_token: input.parse()?,
+            name: input.parse()?,
+            equals_token: input.parse()?,
+            value: input.parse()?,
+            semicolon_token: input.parse()?,
+        })
+    }
+}
+
+#[derive(Debug)]
+struct Flags(Vec<Flag>);
+
+impl Parse for Flags {
+    fn parse(input: ParseStream) -> ParseResult<Self> {
+        let content;
+        let _ = braced!(content in input);
+        let mut flags = vec![];
+        while !content.is_empty() {
+            flags.push(content.parse()?);
+        }
+        Ok(Flags(flags))
+    }
+}
+
+impl Flags {
+    fn expand(&self, struct_name: &syn::Ident, repr: &syn::Type, out_of_line: bool) -> TokenStream {
+        let mut ts = quote! {};
+        let flag_names = self
+            .0
+            .iter()
+            .map(|flag| flag.name.to_string())
+            .collect::<HashSet<_>>();
+        for flag in &self.0 {
+            ts.extend(flag.expand(struct_name, repr, &flag_names, out_of_line));
+        }
+        ts
+    }
+}
+
+pub fn parse(tokens: TokenStream) -> ParseResult<Bitflags> {
+    let parser = Bitflags::parse;
+    parser.parse2(tokens)
+}
diff --git a/src/bindgen/builder.rs b/src/bindgen/builder.rs
new file mode 100644
index 0000000..a0328b4
--- /dev/null
+++ b/src/bindgen/builder.rs
@@ -0,0 +1,424 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::path;
+
+use crate::bindgen::bindings::Bindings;
+use crate::bindgen::cargo::Cargo;
+use crate::bindgen::config::{Braces, Config, Language, Profile, Style};
+use crate::bindgen::error::Error;
+use crate::bindgen::library::Library;
+use crate::bindgen::parser::{self, Parse};
+
+/// A builder for generating a bindings header.
+#[derive(Debug, Clone)]
+pub struct Builder {
+    config: Config,
+    srcs: Vec<path::PathBuf>,
+    lib: Option<(path::PathBuf, Option<String>)>,
+    lib_cargo: Option<Cargo>,
+    std_types: bool,
+    lockfile: Option<path::PathBuf>,
+}
+
+impl Builder {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Builder {
+        Builder {
+            config: Config::default(),
+            srcs: Vec::new(),
+            lib: None,
+            lib_cargo: None,
+            std_types: true,
+            lockfile: None,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn with_header<S: AsRef<str>>(mut self, header: S) -> Builder {
+        self.config.header = Some(String::from(header.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_no_includes(mut self) -> Builder {
+        self.config.no_includes = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_include<S: AsRef<str>>(mut self, include: S) -> Builder {
+        self.config.includes.push(String::from(include.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_sys_include<S: AsRef<str>>(mut self, include: S) -> Builder {
+        self.config
+            .sys_includes
+            .push(String::from(include.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_after_include<S: AsRef<str>>(mut self, line: S) -> Builder {
+        self.config.after_includes = Some(String::from(line.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_trailer<S: AsRef<str>>(mut self, trailer: S) -> Builder {
+        self.config.trailer = Some(String::from(trailer.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_include_guard<S: AsRef<str>>(mut self, include_guard: S) -> Builder {
+        self.config.include_guard = Some(String::from(include_guard.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_pragma_once(mut self, pragma_once: bool) -> Builder {
+        self.config.pragma_once = pragma_once;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_autogen_warning<S: AsRef<str>>(mut self, autogen_warning: S) -> Builder {
+        self.config.autogen_warning = Some(String::from(autogen_warning.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_include_version(mut self, include_version: bool) -> Builder {
+        self.config.include_version = include_version;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_namespace<S: AsRef<str>>(mut self, namespace: S) -> Builder {
+        self.config.namespace = Some(String::from(namespace.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_namespaces<S: AsRef<str>>(mut self, namespaces: &[S]) -> Builder {
+        self.config.namespaces = Some(
+            namespaces
+                .iter()
+                .map(|x| String::from(x.as_ref()))
+                .collect(),
+        );
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_using_namespaces<S: AsRef<str>>(mut self, namespaces: &[S]) -> Builder {
+        self.config.using_namespaces = Some(
+            namespaces
+                .iter()
+                .map(|x| String::from(x.as_ref()))
+                .collect(),
+        );
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_braces(mut self, braces: Braces) -> Builder {
+        self.config.braces = braces;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_line_length(mut self, line_length: usize) -> Builder {
+        self.config.line_length = line_length;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_tab_width(mut self, tab_width: usize) -> Builder {
+        self.config.tab_width = tab_width;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_language(mut self, language: Language) -> Builder {
+        self.config.language = language;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_cpp_compat(mut self, cpp_compat: bool) -> Builder {
+        self.config.cpp_compat = cpp_compat;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_style(mut self, style: Style) -> Builder {
+        self.config.style = style;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn include_item<S: AsRef<str>>(mut self, item_name: S) -> Builder {
+        self.config
+            .export
+            .include
+            .push(String::from(item_name.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn exclude_item<S: AsRef<str>>(mut self, item_name: S) -> Builder {
+        self.config
+            .export
+            .exclude
+            .push(String::from(item_name.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rename_item<S: AsRef<str>>(mut self, from: S, to: S) -> Builder {
+        self.config
+            .export
+            .rename
+            .insert(String::from(from.as_ref()), String::from(to.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_item_prefix<S: AsRef<str>>(mut self, prefix: S) -> Builder {
+        self.config.export.prefix = Some(String::from(prefix.as_ref()));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_deps(mut self, parse_deps: bool) -> Builder {
+        self.config.parse.parse_deps = parse_deps;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_include<S: AsRef<str>>(mut self, include: &[S]) -> Builder {
+        self.config.parse.include =
+            Some(include.iter().map(|x| String::from(x.as_ref())).collect());
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_exclude<S: AsRef<str>>(mut self, exclude: &[S]) -> Builder {
+        self.config.parse.exclude = exclude.iter().map(|x| String::from(x.as_ref())).collect();
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_expand<S: AsRef<str>>(mut self, expand: &[S]) -> Builder {
+        self.config.parse.expand.crates = expand.iter().map(|x| String::from(x.as_ref())).collect();
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_expand_all_features(mut self, expand_all_features: bool) -> Builder {
+        self.config.parse.expand.all_features = expand_all_features;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_expand_default_features(mut self, expand_default_features: bool) -> Builder {
+        self.config.parse.expand.default_features = expand_default_features;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_expand_features<S: AsRef<str>>(mut self, expand_features: &[S]) -> Builder {
+        self.config.parse.expand.features = Some(
+            expand_features
+                .iter()
+                .map(|x| String::from(x.as_ref()))
+                .collect(),
+        );
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_expand_profile(mut self, profile: Profile) -> Builder {
+        self.config.parse.expand.profile = profile;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_parse_extra_bindings<S: AsRef<str>>(mut self, extra_bindings: &[S]) -> Builder {
+        self.config.parse.extra_bindings = extra_bindings
+            .iter()
+            .map(|x| String::from(x.as_ref()))
+            .collect();
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_only_target_dependencies(mut self, only_target_dependencies: bool) -> Builder {
+        self.config.only_target_dependencies = only_target_dependencies;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_documentation(mut self, documentation: bool) -> Builder {
+        self.config.documentation = documentation;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_target_os_define(mut self, platform: &str, preprocessor_define: &str) -> Builder {
+        self.config.defines.insert(
+            format!("target_os = {}", platform),
+            preprocessor_define.to_owned(),
+        );
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_define(mut self, key: &str, value: &str, preprocessor_define: &str) -> Builder {
+        self.config.defines.insert(
+            format!("{} = {}", key, value),
+            preprocessor_define.to_owned(),
+        );
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_config(mut self, config: Config) -> Builder {
+        self.config = config;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_std_types(mut self, std_types: bool) -> Builder {
+        self.std_types = std_types;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_src<P: AsRef<path::Path>>(mut self, src: P) -> Builder {
+        self.srcs.push(src.as_ref().to_owned());
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_crate<P: AsRef<path::Path>>(mut self, lib_dir: P) -> Builder {
+        debug_assert!(self.lib.is_none());
+        debug_assert!(self.lib_cargo.is_none());
+        self.lib = Some((path::PathBuf::from(lib_dir.as_ref()), None));
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_crate_and_name<P: AsRef<path::Path>, S: AsRef<str>>(
+        mut self,
+        lib_dir: P,
+        binding_lib_name: S,
+    ) -> Builder {
+        debug_assert!(self.lib.is_none());
+        debug_assert!(self.lib_cargo.is_none());
+        self.lib = Some((
+            path::PathBuf::from(lib_dir.as_ref()),
+            Some(String::from(binding_lib_name.as_ref())),
+        ));
+        self
+    }
+
+    #[allow(unused)]
+    pub(crate) fn with_cargo(mut self, lib: Cargo) -> Builder {
+        debug_assert!(self.lib.is_none());
+        debug_assert!(self.lib_cargo.is_none());
+        self.lib_cargo = Some(lib);
+        self
+    }
+
+    #[allow(unused)]
+    pub fn with_lockfile<P: AsRef<path::Path>>(mut self, lockfile: P) -> Builder {
+        debug_assert!(self.lockfile.is_none());
+        debug_assert!(self.lib_cargo.is_none());
+        self.lockfile = Some(path::PathBuf::from(lockfile.as_ref()));
+        self
+    }
+
+    pub fn generate(self) -> Result<Bindings, Error> {
+        // If macro expansion is enabled, then cbindgen will attempt to build the crate
+        // and will run its build script which may run cbindgen again. That second run may start
+        // infinite recursion, or overwrite previously written files with bindings.
+        // So if we are called recursively, we are skipping the whole generation
+        // and produce "noop" bindings that won't be able to overwrite anything.
+        if std::env::var("_CBINDGEN_IS_RUNNING").is_ok() {
+            return Ok(Bindings::new(
+                self.config,
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                true,
+            ));
+        }
+
+        let mut result = Parse::new();
+
+        if self.std_types {
+            result.add_std_types();
+        }
+
+        for x in &self.srcs {
+            result.extend_with(&parser::parse_src(x, &self.config)?);
+        }
+
+        if let Some((lib_dir, binding_lib_name)) = self.lib.clone() {
+            let lockfile = self.lockfile.as_ref().and_then(|p| p.to_str());
+
+            let cargo = Cargo::load(
+                &lib_dir,
+                lockfile,
+                binding_lib_name.as_deref(),
+                self.config.parse.parse_deps,
+                self.config.parse.clean,
+                self.config.only_target_dependencies,
+                /* existing_metadata = */ None,
+            )?;
+
+            result.extend_with(&parser::parse_lib(cargo, &self.config)?);
+        } else if let Some(cargo) = self.lib_cargo.clone() {
+            result.extend_with(&parser::parse_lib(cargo, &self.config)?);
+        }
+
+        result.source_files.extend_from_slice(self.srcs.as_slice());
+
+        Library::new(
+            self.config,
+            result.constants,
+            result.globals,
+            result.enums,
+            result.structs,
+            result.unions,
+            result.opaque_items,
+            result.typedefs,
+            result.functions,
+            result.source_files,
+        )
+        .generate()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn with_style() {
+        assert_eq!(
+            Style::Tag,
+            Builder::new().with_style(Style::Tag).config.style
+        );
+    }
+}
diff --git a/src/bindgen/cargo/cargo.rs b/src/bindgen/cargo/cargo.rs
new file mode 100644
index 0000000..69cf938
--- /dev/null
+++ b/src/bindgen/cargo/cargo.rs
@@ -0,0 +1,252 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::path::{Path, PathBuf};
+
+use crate::bindgen::cargo::cargo_expand;
+use crate::bindgen::cargo::cargo_lock::{self, Lock};
+pub(crate) use crate::bindgen::cargo::cargo_metadata::PackageRef;
+use crate::bindgen::cargo::cargo_metadata::{self, Metadata};
+use crate::bindgen::cargo::cargo_toml;
+use crate::bindgen::config::Profile;
+use crate::bindgen::error::Error;
+use crate::bindgen::ir::Cfg;
+
+/// Parse a dependency string used in Cargo.lock
+fn parse_dep_string(dep_string: &str) -> (&str, Option<&str>) {
+    let split: Vec<&str> = dep_string.split_whitespace().collect();
+
+    (split[0], split.get(1).cloned())
+}
+
+/// A collection of metadata for a library from cargo.
+#[derive(Clone, Debug)]
+pub(crate) struct Cargo {
+    manifest_path: PathBuf,
+    binding_crate_name: String,
+    lock: Option<Lock>,
+    metadata: Metadata,
+    clean: bool,
+}
+
+impl Cargo {
+    /// Gather metadata from cargo for a specific library and binding crate
+    /// name. If dependency finding isn't needed then Cargo.lock files don't
+    /// need to be parsed.
+    pub(crate) fn load(
+        crate_dir: &Path,
+        lock_file: Option<&str>,
+        binding_crate_name: Option<&str>,
+        use_cargo_lock: bool,
+        clean: bool,
+        only_target_dependencies: bool,
+        existing_metadata_file: Option<&Path>,
+    ) -> Result<Cargo, Error> {
+        let toml_path = crate_dir.join("Cargo.toml");
+        let metadata =
+            cargo_metadata::metadata(&toml_path, existing_metadata_file, only_target_dependencies)
+                .map_err(|x| Error::CargoMetadata(toml_path.to_str().unwrap().to_owned(), x))?;
+        let lock_path = lock_file
+            .map(PathBuf::from)
+            .unwrap_or_else(|| Path::new(&metadata.workspace_root).join("Cargo.lock"));
+
+        let lock = if use_cargo_lock {
+            match cargo_lock::lock(&lock_path) {
+                Ok(lock) => Some(lock),
+                Err(x) => {
+                    warn!("Couldn't load lock file {:?}: {:?}", lock_path, x);
+                    None
+                }
+            }
+        } else {
+            None
+        };
+
+        // Use the specified binding crate name or infer it from the manifest
+        let binding_crate_name = match binding_crate_name {
+            Some(s) => s.to_owned(),
+            None => {
+                let manifest = cargo_toml::manifest(&toml_path)
+                    .map_err(|x| Error::CargoToml(toml_path.to_str().unwrap().to_owned(), x))?;
+                manifest.package.name
+            }
+        };
+
+        Ok(Cargo {
+            manifest_path: toml_path,
+            binding_crate_name,
+            lock,
+            metadata,
+            clean,
+        })
+    }
+
+    pub(crate) fn binding_crate_name(&self) -> &str {
+        &self.binding_crate_name
+    }
+
+    pub(crate) fn binding_crate_ref(&self) -> PackageRef {
+        match self.find_pkg_ref(&self.binding_crate_name) {
+            Some(pkg_ref) => pkg_ref,
+            None => panic!(
+                "Unable to find {} for {:?}",
+                self.binding_crate_name, self.manifest_path
+            ),
+        }
+    }
+
+    pub(crate) fn dependencies(&self, package: &PackageRef) -> Vec<(PackageRef, Option<Cfg>)> {
+        let lock = match self.lock {
+            Some(ref lock) => lock,
+            None => return vec![],
+        };
+
+        let mut dependencies = None;
+
+        // Find the dependencies listing in the lockfile
+        if let Some(ref root) = lock.root {
+            // If the version is not on the lockfile then it shouldn't be
+            // ambiguous.
+            if root.name == package.name
+                && package
+                    .version
+                    .as_ref()
+                    .map_or(true, |v| *v == root.version)
+            {
+                dependencies = root.dependencies.as_ref();
+            }
+        }
+        if dependencies.is_none() {
+            if let Some(ref lock_packages) = lock.package {
+                for lock_package in lock_packages {
+                    if lock_package.name == package.name
+                        && package
+                            .version
+                            .as_ref()
+                            .map_or(true, |v| *v == lock_package.version)
+                    {
+                        dependencies = lock_package.dependencies.as_ref();
+                        break;
+                    }
+                }
+            }
+        }
+        if dependencies.is_none() {
+            return vec![];
+        }
+
+        dependencies
+            .unwrap()
+            .iter()
+            .map(|dep| {
+                let (dep_name, dep_version) = parse_dep_string(dep);
+
+                // If a version was not specified find the only package with the name of the dependency
+                let dep_version = dep_version.or_else(|| {
+                    let mut versions = self.metadata.packages.iter().filter_map(|package| {
+                        if package.name_and_version.name != dep_name {
+                            return None;
+                        }
+                        package.name_and_version.version.as_deref()
+                    });
+
+                    // If the iterator contains more items, meaning multiple versions of the same
+                    // package are present, warn! amd abort.
+                    let version = versions.next();
+                    if versions.next().is_none() {
+                        version
+                    } else {
+                        warn!("when looking for a version for package {}, multiple versions where found", dep_name);
+                        None
+                    }
+                });
+
+                // Try to find the cfgs in the Cargo.toml
+                let cfg = self
+                    .metadata
+                    .packages
+                    .get(package)
+                    .and_then(|meta_package| meta_package.dependencies.get(dep_name))
+                    .and_then(Cfg::load_metadata);
+
+                let package_ref = PackageRef {
+                    name: dep_name.to_owned(),
+                    version: dep_version.map(|v| v.to_owned()),
+                };
+
+                (package_ref, cfg)
+            })
+            .collect()
+    }
+
+    /// Finds the package reference in `cargo metadata` that has `package_name`
+    /// ignoring the version.
+    fn find_pkg_ref(&self, package_name: &str) -> Option<PackageRef> {
+        for package in &self.metadata.packages {
+            if package.name_and_version.name == package_name {
+                return Some(package.name_and_version.clone());
+            }
+        }
+        None
+    }
+
+    /// Finds the directory for a specified package reference.
+    #[allow(unused)]
+    pub(crate) fn find_crate_dir(&self, package: &PackageRef) -> Option<PathBuf> {
+        self.metadata
+            .packages
+            .get(package)
+            .and_then(|meta_package| {
+                Path::new(&meta_package.manifest_path)
+                    .parent()
+                    .map(|x| x.to_owned())
+            })
+    }
+
+    /// Finds `src/lib.rs` for a specified package reference.
+    pub(crate) fn find_crate_src(&self, package: &PackageRef) -> Option<PathBuf> {
+        let kind_lib = String::from("lib");
+        let kind_staticlib = String::from("staticlib");
+        let kind_rlib = String::from("rlib");
+        let kind_cdylib = String::from("cdylib");
+        let kind_dylib = String::from("dylib");
+
+        self.metadata
+            .packages
+            .get(package)
+            .and_then(|meta_package| {
+                for target in &meta_package.targets {
+                    if target.kind.contains(&kind_lib)
+                        || target.kind.contains(&kind_staticlib)
+                        || target.kind.contains(&kind_rlib)
+                        || target.kind.contains(&kind_cdylib)
+                        || target.kind.contains(&kind_dylib)
+                    {
+                        return Some(PathBuf::from(&target.src_path));
+                    }
+                }
+                None
+            })
+    }
+
+    pub(crate) fn expand_crate(
+        &self,
+        package: &PackageRef,
+        expand_all_features: bool,
+        expand_default_features: bool,
+        expand_features: &Option<Vec<String>>,
+        profile: Profile,
+    ) -> Result<String, cargo_expand::Error> {
+        cargo_expand::expand(
+            &self.manifest_path,
+            &package.name,
+            package.version.as_deref(),
+            self.clean,
+            expand_all_features,
+            expand_default_features,
+            expand_features,
+            profile,
+        )
+    }
+}
diff --git a/src/bindgen/cargo/cargo_expand.rs b/src/bindgen/cargo/cargo_expand.rs
new file mode 100644
index 0000000..565a0d1
--- /dev/null
+++ b/src/bindgen/cargo/cargo_expand.rs
@@ -0,0 +1,145 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::bindgen::config::Profile;
+use std::env;
+use std::error;
+use std::fmt;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::str::{from_utf8, Utf8Error};
+
+extern crate tempfile;
+use self::tempfile::Builder;
+
+#[derive(Debug)]
+/// Possible errors that can occur during `rustc -Zunpretty=expanded`.
+pub enum Error {
+    /// Error during creation of temporary directory
+    Io(io::Error),
+    /// Output of `cargo metadata` was not valid utf8
+    Utf8(Utf8Error),
+    /// Error during execution of `cargo rustc -Zunpretty=expanded`
+    Compile(String),
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+impl From<Utf8Error> for Error {
+    fn from(err: Utf8Error) -> Self {
+        Error::Utf8(err)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::Io(ref err) => err.fmt(f),
+            Error::Utf8(ref err) => err.fmt(f),
+            Error::Compile(ref err) => write!(f, "{}", err),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            Error::Io(ref err) => Some(err),
+            Error::Utf8(ref err) => Some(err),
+            Error::Compile(..) => None,
+        }
+    }
+}
+
+/// Use rustc to expand and pretty print the crate into a single file,
+/// removing any macros in the process.
+#[allow(clippy::too_many_arguments)]
+pub fn expand(
+    manifest_path: &Path,
+    crate_name: &str,
+    version: Option<&str>,
+    use_tempdir: bool,
+    expand_all_features: bool,
+    expand_default_features: bool,
+    expand_features: &Option<Vec<String>>,
+    profile: Profile,
+) -> Result<String, Error> {
+    let cargo = env::var("CARGO").unwrap_or_else(|_| String::from("cargo"));
+    let mut cmd = Command::new(cargo);
+
+    let mut _temp_dir = None; // drop guard
+    if use_tempdir {
+        _temp_dir = Some(Builder::new().prefix("cbindgen-expand").tempdir()?);
+        cmd.env("CARGO_TARGET_DIR", _temp_dir.unwrap().path());
+    } else if let Ok(ref path) = env::var("CARGO_EXPAND_TARGET_DIR") {
+        cmd.env("CARGO_TARGET_DIR", path);
+    } else if let Ok(ref path) = env::var("OUT_DIR") {
+        // When cbindgen was started programatically from a build.rs file, Cargo is running and
+        // locking the default target directory. In this case we need to use another directory,
+        // else we would end up in a deadlock. If Cargo is running `OUT_DIR` will be set, so we
+        // can use a directory relative to that.
+        cmd.env("CARGO_TARGET_DIR", PathBuf::from(path).join("expanded"));
+    }
+
+    // Set this variable so that we don't call it recursively if we expand a crate that is using
+    // cbindgen
+    cmd.env("_CBINDGEN_IS_RUNNING", "1");
+
+    cmd.arg("rustc");
+    cmd.arg("--lib");
+    // When build with the release profile we can't choose the `check` profile.
+    if profile != Profile::Release {
+        cmd.arg("--profile=check");
+    }
+    cmd.arg("--manifest-path");
+    cmd.arg(manifest_path);
+    if let Some(features) = expand_features {
+        cmd.arg("--features");
+        let mut features_str = String::new();
+        for (index, feature) in features.iter().enumerate() {
+            if index != 0 {
+                features_str.push(' ');
+            }
+            features_str.push_str(feature);
+        }
+        cmd.arg(features_str);
+    }
+    if expand_all_features {
+        cmd.arg("--all-features");
+    }
+    if !expand_default_features {
+        cmd.arg("--no-default-features");
+    }
+    match profile {
+        Profile::Debug => {}
+        Profile::Release => {
+            cmd.arg("--release");
+        }
+    }
+    cmd.arg("-p");
+    let mut package = crate_name.to_owned();
+    if let Some(version) = version {
+        package.push(':');
+        package.push_str(version);
+    }
+    cmd.arg(&package);
+    cmd.arg("--verbose");
+    cmd.arg("--");
+    cmd.arg("-Zunpretty=expanded");
+    info!("Command: {:?}", cmd);
+    let output = cmd.output()?;
+
+    let src = from_utf8(&output.stdout)?.to_owned();
+    let error = from_utf8(&output.stderr)?.to_owned();
+
+    if src.is_empty() {
+        Err(Error::Compile(error))
+    } else {
+        Ok(src)
+    }
+}
diff --git a/src/bindgen/cargo/cargo_lock.rs b/src/bindgen/cargo/cargo_lock.rs
new file mode 100644
index 0000000..9302082
--- /dev/null
+++ b/src/bindgen/cargo/cargo_lock.rs
@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::fs::File;
+use std::io;
+use std::io::Read;
+use std::path::Path;
+
+#[derive(Debug)]
+/// Possible errors that can occur during Cargo.toml parsing.
+pub enum Error {
+    /// Error during reading of Cargo.toml
+    Io(io::Error),
+    /// Deserialization error
+    Toml(toml::de::Error),
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+impl From<toml::de::Error> for Error {
+    fn from(err: toml::de::Error) -> Self {
+        Error::Toml(err)
+    }
+}
+
+#[derive(Clone, Deserialize, Debug)]
+pub struct Lock {
+    pub root: Option<Package>,
+    pub package: Option<Vec<Package>>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+pub struct Package {
+    pub name: String,
+    pub version: String,
+    /// A list of dependencies formatted like "NAME VERSION-OPT REGISTRY-OPT"
+    pub dependencies: Option<Vec<String>>,
+}
+
+/// Parse the Cargo.toml for a given path
+pub fn lock(manifest_path: &Path) -> Result<Lock, Error> {
+    let mut s = String::new();
+    let mut f = File::open(manifest_path)?;
+    f.read_to_string(&mut s)?;
+
+    toml::from_str::<Lock>(&s).map_err(|x| x.into())
+}
diff --git a/src/bindgen/cargo/cargo_metadata.rs b/src/bindgen/cargo/cargo_metadata.rs
new file mode 100644
index 0000000..01ab80f
--- /dev/null
+++ b/src/bindgen/cargo/cargo_metadata.rs
@@ -0,0 +1,253 @@
+#![deny(missing_docs)]
+#![allow(dead_code)]
+//! Structured access to the output of `cargo metadata`
+//! Usually used from within a `cargo-*` executable
+
+// Forked from `https://github.com/oli-obk/cargo_metadata`
+// Modifications:
+//   1. Remove `resolve` from Metadata because it was causing parse failures
+//   2. Fix the `manifest-path` argument
+//   3. Add `--all-features` argument
+//   4. Remove the `--no-deps` argument
+
+use std::borrow::{Borrow, Cow};
+use std::collections::{HashMap, HashSet};
+use std::env;
+use std::error;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+use std::io;
+use std::path::Path;
+use std::process::{Command, Output};
+use std::str::Utf8Error;
+
+#[derive(Clone, Deserialize, Debug)]
+/// Starting point for metadata returned by `cargo metadata`
+pub struct Metadata {
+    /// A list of all crates referenced by this crate (and the crate itself)
+    pub packages: HashSet<Package>,
+    version: usize,
+    /// path to the workspace containing the `Cargo.lock`
+    pub workspace_root: String,
+}
+
+/// A reference to a package including it's name and the specific version.
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub struct PackageRef {
+    pub name: String,
+    pub version: Option<String>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+/// A crate
+pub struct Package {
+    #[serde(flatten)]
+    pub name_and_version: PackageRef,
+    id: String,
+    source: Option<String>,
+    /// List of dependencies of this particular package
+    pub dependencies: HashSet<Dependency>,
+    /// Targets provided by the crate (lib, bin, example, test, ...)
+    pub targets: Vec<Target>,
+    features: HashMap<String, Vec<String>>,
+    /// path containing the `Cargo.toml`
+    pub manifest_path: String,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+/// A dependency of the main crate
+pub struct Dependency {
+    /// Name as given in the `Cargo.toml`
+    pub name: String,
+    source: Option<String>,
+    /// Whether this is required or optional
+    pub req: String,
+    kind: Option<String>,
+    optional: bool,
+    uses_default_features: bool,
+    features: Vec<String>,
+    pub target: Option<String>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+/// A single target (lib, bin, example, ...) provided by a crate
+pub struct Target {
+    /// Name as given in the `Cargo.toml` or generated from the file name
+    pub name: String,
+    /// Kind of target ("bin", "example", "test", "bench", "lib")
+    pub kind: Vec<String>,
+    /// Almost the same as `kind`, except when an example is a library instad of an executable.
+    /// In that case `crate_types` contains things like `rlib` and `dylib` while `kind` is `example`
+    #[serde(default)]
+    pub crate_types: Vec<String>,
+    /// Path to the main source file of the target
+    pub src_path: String,
+}
+
+#[derive(Debug)]
+/// Possible errors that can occur during metadata parsing.
+pub enum Error {
+    /// Error during execution of `cargo metadata`
+    Io(io::Error),
+    /// Metadata extraction failure
+    Metadata(Output),
+    /// Output of `cargo metadata` was not valid utf8
+    Utf8(Utf8Error),
+    /// Deserialization error (structure of json did not match expected structure)
+    Json(serde_json::Error),
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+impl From<Utf8Error> for Error {
+    fn from(err: Utf8Error) -> Self {
+        Error::Utf8(err)
+    }
+}
+impl From<serde_json::Error> for Error {
+    fn from(err: serde_json::Error) -> Self {
+        Error::Json(err)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::Io(ref err) => err.fmt(f),
+            Error::Metadata(_) => write!(f, "Metadata error"),
+            Error::Utf8(ref err) => err.fmt(f),
+            Error::Json(ref err) => err.fmt(f),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            Error::Io(ref err) => Some(err),
+            Error::Metadata(_) => None,
+            Error::Utf8(ref err) => Some(err),
+            Error::Json(ref err) => Some(err),
+        }
+    }
+}
+
+// Implementations that let us lookup Packages and Dependencies by name (string)
+
+impl Borrow<PackageRef> for Package {
+    fn borrow(&self) -> &PackageRef {
+        &self.name_and_version
+    }
+}
+
+impl Hash for Package {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name_and_version.hash(state);
+    }
+}
+
+impl PartialEq for Package {
+    fn eq(&self, other: &Self) -> bool {
+        self.name_and_version == other.name_and_version
+    }
+}
+
+impl Eq for Package {}
+
+impl Borrow<str> for Dependency {
+    fn borrow(&self) -> &str {
+        &self.name
+    }
+}
+
+impl Hash for Dependency {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+    }
+}
+
+impl PartialEq for Dependency {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
+impl Eq for Dependency {}
+
+fn discover_target(manifest_path: &Path) -> Option<String> {
+    if let Ok(target) = std::env::var("TARGET") {
+        return Some(target);
+    }
+
+    // We must be running as a standalone script, not under cargo.
+    // Let's use the host platform instead.
+    // We figure out the host platform through rustc and use that.
+    // We unfortunatelly cannot go through cargo, since cargo rustc _also_ builds.
+    // If `rustc` fails to run, we just fall back to not passing --filter-platforms.
+    //
+    // NOTE: We set the current directory in case of rustup shenanigans.
+    let rustc = env::var("RUSTC").unwrap_or_else(|_| String::from("rustc"));
+    debug!("Discovering host platform by {:?}", rustc);
+
+    let rustc_output = Command::new(rustc)
+        .current_dir(manifest_path.parent().unwrap())
+        .arg("-vV")
+        .output();
+    let rustc_output = match rustc_output {
+        Ok(ref out) => String::from_utf8_lossy(&out.stdout),
+        Err(..) => return None,
+    };
+
+    let field = "host: ";
+    rustc_output
+        .lines()
+        .find_map(|l| l.strip_prefix(field).map(|stripped| stripped.to_string()))
+}
+
+/// The main entry point to obtaining metadata
+pub fn metadata(
+    manifest_path: &Path,
+    existing_metadata_file: Option<&Path>,
+    only_target: bool,
+) -> Result<Metadata, Error> {
+    let output;
+    let metadata = match existing_metadata_file {
+        Some(path) => Cow::Owned(std::fs::read_to_string(path)?),
+        None => {
+            let target = if only_target {
+                let target = discover_target(manifest_path);
+                if target.is_none() {
+                    warn!(
+                        "Failed to discover host platform for cargo metadata; \
+                        will fetch dependencies for all platforms."
+                    );
+                }
+                target
+            } else {
+                None
+            };
+
+            let cargo = env::var("CARGO").unwrap_or_else(|_| String::from("cargo"));
+            let mut cmd = Command::new(cargo);
+            cmd.arg("metadata");
+            cmd.arg("--all-features");
+            cmd.arg("--format-version").arg("1");
+            if let Some(target) = target {
+                cmd.arg("--filter-platform").arg(target);
+            }
+            cmd.arg("--manifest-path");
+            cmd.arg(manifest_path);
+            output = cmd.output()?;
+            if !output.status.success() {
+                return Err(Error::Metadata(output));
+            }
+            Cow::Borrowed(std::str::from_utf8(&output.stdout)?)
+        }
+    };
+
+    let meta: Metadata = serde_json::from_str(&metadata)?;
+    Ok(meta)
+}
diff --git a/src/bindgen/cargo/cargo_toml.rs b/src/bindgen/cargo/cargo_toml.rs
new file mode 100644
index 0000000..998176e
--- /dev/null
+++ b/src/bindgen/cargo/cargo_toml.rs
@@ -0,0 +1,67 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::error;
+use std::fmt;
+use std::fs::File;
+use std::io;
+use std::io::Read;
+use std::path::Path;
+
+#[derive(Debug)]
+/// Possible errors that can occur during Cargo.toml parsing.
+pub enum Error {
+    /// Error during reading of Cargo.toml
+    Io(io::Error),
+    /// Deserialization error
+    Toml(toml::de::Error),
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+impl From<toml::de::Error> for Error {
+    fn from(err: toml::de::Error) -> Self {
+        Error::Toml(err)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::Io(ref err) => err.fmt(f),
+            Error::Toml(ref err) => err.fmt(f),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            Error::Io(ref err) => Some(err),
+            Error::Toml(ref err) => Some(err),
+        }
+    }
+}
+
+#[derive(Clone, Deserialize, Debug)]
+pub struct Manifest {
+    pub package: Package,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+pub struct Package {
+    pub name: String,
+}
+
+/// Parse the Cargo.toml for a given path
+pub fn manifest(manifest_path: &Path) -> Result<Manifest, Error> {
+    let mut s = String::new();
+    let mut f = File::open(manifest_path)?;
+    f.read_to_string(&mut s)?;
+
+    toml::from_str::<Manifest>(&s).map_err(|x| x.into())
+}
diff --git a/src/bindgen/cargo/mod.rs b/src/bindgen/cargo/mod.rs
new file mode 100644
index 0000000..19fef54
--- /dev/null
+++ b/src/bindgen/cargo/mod.rs
@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#[allow(clippy::module_inception)]
+mod cargo;
+pub(crate) mod cargo_expand;
+pub(crate) mod cargo_lock;
+pub(crate) mod cargo_metadata;
+pub(crate) mod cargo_toml;
+
+pub(crate) use self::cargo::*;
diff --git a/src/bindgen/cdecl.rs b/src/bindgen/cdecl.rs
new file mode 100644
index 0000000..a9c5a0f
--- /dev/null
+++ b/src/bindgen/cdecl.rs
@@ -0,0 +1,372 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use crate::bindgen::config::Layout;
+use crate::bindgen::declarationtyperesolver::DeclarationType;
+use crate::bindgen::ir::{ConstExpr, Function, GenericArgument, Type};
+use crate::bindgen::writer::{ListType, SourceWriter};
+use crate::bindgen::{Config, Language};
+
+// This code is for translating Rust types into C declarations.
+// See Section 6.7, Declarations, in the C standard for background.
+// http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
+
+enum CDeclarator {
+    Ptr {
+        is_const: bool,
+        is_nullable: bool,
+        is_ref: bool,
+    },
+    Array(String),
+    Func {
+        args: Vec<(Option<String>, CDecl)>,
+        layout: Layout,
+        never_return: bool,
+    },
+}
+
+impl CDeclarator {
+    fn is_ptr(&self) -> bool {
+        matches!(self, CDeclarator::Ptr { .. } | CDeclarator::Func { .. })
+    }
+}
+
+struct CDecl {
+    type_qualifers: String,
+    type_name: String,
+    type_generic_args: Vec<GenericArgument>,
+    declarators: Vec<CDeclarator>,
+    type_ctype: Option<DeclarationType>,
+    deprecated: Option<String>,
+}
+
+impl CDecl {
+    fn new() -> CDecl {
+        CDecl {
+            type_qualifers: String::new(),
+            type_name: String::new(),
+            type_generic_args: Vec::new(),
+            declarators: Vec::new(),
+            type_ctype: None,
+            deprecated: None,
+        }
+    }
+
+    fn from_type(t: &Type, config: &Config) -> CDecl {
+        let mut cdecl = CDecl::new();
+        cdecl.build_type(t, false, config);
+        cdecl
+    }
+
+    fn from_func_arg(t: &Type, array_length: Option<&str>, config: &Config) -> CDecl {
+        let mut cdecl = CDecl::new();
+        let length = match array_length {
+            Some(l) => l,
+            None => return CDecl::from_type(t, config),
+        };
+        let (ty, is_const) = match t {
+            Type::Ptr { ty, is_const, .. } => (ty, is_const),
+            _ => unreachable!(
+                "Should never have an array length for a non pointer type {:?}",
+                t
+            ),
+        };
+        let ptr_as_array = Type::Array(ty.clone(), ConstExpr::Value(length.to_string()));
+        cdecl.build_type(&ptr_as_array, *is_const, config);
+        cdecl
+    }
+
+    fn from_func(f: &Function, layout: Layout, config: &Config) -> CDecl {
+        let mut cdecl = CDecl::new();
+        cdecl.build_func(f, layout, config);
+        cdecl
+    }
+
+    fn build_func(&mut self, f: &Function, layout: Layout, config: &Config) {
+        let args = f
+            .args
+            .iter()
+            .map(|arg| {
+                (
+                    arg.name.clone(),
+                    CDecl::from_func_arg(&arg.ty, arg.array_length.as_deref(), config),
+                )
+            })
+            .collect();
+        self.declarators.push(CDeclarator::Func {
+            args,
+            layout,
+            never_return: f.never_return,
+        });
+        self.deprecated = f.annotations.deprecated.clone();
+        self.build_type(&f.ret, false, config);
+    }
+
+    fn build_type(&mut self, t: &Type, is_const: bool, config: &Config) {
+        match t {
+            Type::Path(ref generic) => {
+                if is_const {
+                    assert!(
+                        self.type_qualifers.is_empty(),
+                        "error generating cdecl for {:?}",
+                        t
+                    );
+                    self.type_qualifers = "const".to_owned();
+                }
+
+                assert!(
+                    self.type_name.is_empty(),
+                    "error generating cdecl for {:?}",
+                    t
+                );
+                self.type_name = generic.export_name().to_owned();
+                assert!(
+                    self.type_generic_args.is_empty(),
+                    "error generating cdecl for {:?}",
+                    t
+                );
+                self.type_generic_args = generic.generics().to_owned();
+                self.type_ctype = generic.ctype().cloned();
+            }
+            Type::Primitive(ref p) => {
+                if is_const {
+                    assert!(
+                        self.type_qualifers.is_empty(),
+                        "error generating cdecl for {:?}",
+                        t
+                    );
+                    self.type_qualifers = "const".to_owned();
+                }
+
+                assert!(
+                    self.type_name.is_empty(),
+                    "error generating cdecl for {:?}",
+                    t
+                );
+                self.type_name = p.to_repr_c(config).to_string();
+            }
+            Type::Ptr {
+                ref ty,
+                is_nullable,
+                is_const: ptr_is_const,
+                is_ref,
+            } => {
+                self.declarators.push(CDeclarator::Ptr {
+                    is_const,
+                    is_nullable: *is_nullable,
+                    is_ref: *is_ref,
+                });
+                self.build_type(ty, *ptr_is_const, config);
+            }
+            Type::Array(ref t, ref constant) => {
+                let len = constant.as_str().to_owned();
+                self.declarators.push(CDeclarator::Array(len));
+                self.build_type(t, is_const, config);
+            }
+            Type::FuncPtr {
+                ref ret,
+                ref args,
+                is_nullable: _,
+                never_return,
+            } => {
+                let args = args
+                    .iter()
+                    .map(|(ref name, ref ty)| (name.clone(), CDecl::from_type(ty, config)))
+                    .collect();
+                self.declarators.push(CDeclarator::Ptr {
+                    is_const: false,
+                    is_nullable: true,
+                    is_ref: false,
+                });
+                self.declarators.push(CDeclarator::Func {
+                    args,
+                    layout: config.function.args.clone(),
+                    never_return: *never_return,
+                });
+                self.build_type(ret, false, config);
+            }
+        }
+    }
+
+    fn write<F: Write>(&self, out: &mut SourceWriter<F>, ident: Option<&str>, config: &Config) {
+        // Write the type-specifier and type-qualifier first
+        if !self.type_qualifers.is_empty() {
+            write!(out, "{} ", self.type_qualifers);
+        }
+
+        if config.language != Language::Cython {
+            if let Some(ref ctype) = self.type_ctype {
+                write!(out, "{} ", ctype.to_str());
+            }
+        }
+
+        write!(out, "{}", self.type_name);
+
+        if !self.type_generic_args.is_empty() {
+            out.write("<");
+            out.write_horizontal_source_list(&self.type_generic_args, ListType::Join(", "));
+            out.write(">");
+        }
+
+        // When we have an identifier, put a space between the type and the declarators
+        if ident.is_some() {
+            out.write(" ");
+        }
+
+        // Write the left part of declarators before the identifier
+        let mut iter_rev = self.declarators.iter().rev().peekable();
+
+        #[allow(clippy::while_let_on_iterator)]
+        while let Some(declarator) = iter_rev.next() {
+            let next_is_pointer = iter_rev.peek().map_or(false, |x| x.is_ptr());
+
+            match *declarator {
+                CDeclarator::Ptr {
+                    is_const,
+                    is_nullable,
+                    is_ref,
+                } => {
+                    out.write(if is_ref { "&" } else { "*" });
+                    if is_const {
+                        out.write("const ");
+                    }
+                    if !is_nullable && !is_ref && config.language != Language::Cython {
+                        if let Some(attr) = &config.pointer.non_null_attribute {
+                            write!(out, "{} ", attr);
+                        }
+                    }
+                }
+                CDeclarator::Array(..) => {
+                    if next_is_pointer {
+                        out.write("(");
+                    }
+                }
+                CDeclarator::Func { .. } => {
+                    if next_is_pointer {
+                        out.write("(");
+                    }
+                }
+            }
+        }
+
+        // Write the identifier
+        if let Some(ident) = ident {
+            write!(out, "{}", ident);
+        }
+
+        // Write the right part of declarators after the identifier
+        let mut iter = self.declarators.iter();
+        let mut last_was_pointer = false;
+
+        #[allow(clippy::while_let_on_iterator)]
+        while let Some(declarator) = iter.next() {
+            match *declarator {
+                CDeclarator::Ptr { .. } => {
+                    last_was_pointer = true;
+                }
+                CDeclarator::Array(ref constant) => {
+                    if last_was_pointer {
+                        out.write(")");
+                    }
+                    write!(out, "[{}]", constant);
+
+                    last_was_pointer = false;
+                }
+                CDeclarator::Func {
+                    ref args,
+                    ref layout,
+                    never_return,
+                } => {
+                    if last_was_pointer {
+                        out.write(")");
+                    }
+
+                    out.write("(");
+                    if args.is_empty() && config.language == Language::C {
+                        out.write("void");
+                    }
+
+                    fn write_vertical<F: Write>(
+                        out: &mut SourceWriter<F>,
+                        config: &Config,
+                        args: &[(Option<String>, CDecl)],
+                    ) {
+                        let align_length = out.line_length_for_align();
+                        out.push_set_spaces(align_length);
+                        for (i, (arg_ident, arg_ty)) in args.iter().enumerate() {
+                            if i != 0 {
+                                out.write(",");
+                                out.new_line();
+                            }
+
+                            // Convert &Option<String> to Option<&str>
+                            let arg_ident = arg_ident.as_ref().map(|x| x.as_ref());
+
+                            arg_ty.write(out, arg_ident, config);
+                        }
+                        out.pop_tab();
+                    }
+
+                    fn write_horizontal<F: Write>(
+                        out: &mut SourceWriter<F>,
+                        config: &Config,
+                        args: &[(Option<String>, CDecl)],
+                    ) {
+                        for (i, (arg_ident, arg_ty)) in args.iter().enumerate() {
+                            if i != 0 {
+                                out.write(", ");
+                            }
+
+                            // Convert &Option<String> to Option<&str>
+                            let arg_ident = arg_ident.as_ref().map(|x| x.as_ref());
+
+                            arg_ty.write(out, arg_ident, config);
+                        }
+                    }
+
+                    match layout {
+                        Layout::Vertical => write_vertical(out, config, args),
+                        Layout::Horizontal => write_horizontal(out, config, args),
+                        Layout::Auto => {
+                            if !out.try_write(
+                                |out| write_horizontal(out, config, args),
+                                config.line_length,
+                            ) {
+                                write_vertical(out, config, args)
+                            }
+                        }
+                    }
+                    out.write(")");
+
+                    if never_return && config.language != Language::Cython {
+                        if let Some(ref no_return_attr) = config.function.no_return {
+                            out.write_fmt(format_args!(" {}", no_return_attr));
+                        }
+                    }
+
+                    last_was_pointer = true;
+                }
+            }
+        }
+    }
+}
+
+pub fn write_func<F: Write>(
+    out: &mut SourceWriter<F>,
+    f: &Function,
+    layout: Layout,
+    config: &Config,
+) {
+    CDecl::from_func(f, layout, config).write(out, Some(f.path().name()), config);
+}
+
+pub fn write_field<F: Write>(out: &mut SourceWriter<F>, t: &Type, ident: &str, config: &Config) {
+    CDecl::from_type(t, config).write(out, Some(ident), config);
+}
+
+pub fn write_type<F: Write>(out: &mut SourceWriter<F>, t: &Type, config: &Config) {
+    CDecl::from_type(t, config).write(out, None, config);
+}
diff --git a/src/bindgen/config.rs b/src/bindgen/config.rs
new file mode 100644
index 0000000..5012414
--- /dev/null
+++ b/src/bindgen/config.rs
@@ -0,0 +1,1114 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::{BTreeMap, HashMap};
+use std::default::Default;
+use std::str::FromStr;
+use std::{fmt, fs, path::Path as StdPath, path::PathBuf as StdPathBuf};
+
+use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
+use serde::de::{Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
+
+use crate::bindgen::ir::annotation::AnnotationSet;
+use crate::bindgen::ir::path::Path;
+use crate::bindgen::ir::repr::ReprAlign;
+pub use crate::bindgen::rename::RenameRule;
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// A language type to generate bindings for.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Language {
+    Cxx,
+    C,
+    Cython,
+}
+
+impl FromStr for Language {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Language, Self::Err> {
+        match s {
+            "cxx" => Ok(Language::Cxx),
+            "Cxx" => Ok(Language::Cxx),
+            "CXX" => Ok(Language::Cxx),
+            "cpp" => Ok(Language::Cxx),
+            "Cpp" => Ok(Language::Cxx),
+            "CPP" => Ok(Language::Cxx),
+            "c++" => Ok(Language::Cxx),
+            "C++" => Ok(Language::Cxx),
+            "c" => Ok(Language::C),
+            "C" => Ok(Language::C),
+            "cython" => Ok(Language::Cython),
+            "Cython" => Ok(Language::Cython),
+            _ => Err(format!("Unrecognized Language: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(Language);
+
+impl Language {
+    pub(crate) fn typedef(self) -> &'static str {
+        match self {
+            Language::Cxx | Language::C => "typedef",
+            Language::Cython => "ctypedef",
+        }
+    }
+}
+
+/// Controls what type of line endings are used in the generated code.
+#[derive(Debug, Clone, Copy)]
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Default)]
+pub enum LineEndingStyle {
+    /// Use Unix-style linefeed characters
+    #[default]
+    LF,
+    /// Use classic Mac-style carriage-return characters
+    CR,
+    /// Use Windows-style carriage-return and linefeed characters
+    CRLF,
+    /// Use the native mode for the platform: CRLF on Windows, LF everywhere else.
+    Native,
+}
+
+impl LineEndingStyle {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::LF => "\n",
+            Self::CR => "\r",
+            Self::CRLF => "\r\n",
+            Self::Native => {
+                #[cfg(target_os = "windows")]
+                {
+                    Self::CRLF.as_str()
+                }
+                #[cfg(not(target_os = "windows"))]
+                {
+                    Self::LF.as_str()
+                }
+            }
+        }
+    }
+}
+
+impl FromStr for LineEndingStyle {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_ref() {
+            "native" => Ok(Self::Native),
+            "lf" => Ok(Self::LF),
+            "crlf" => Ok(Self::CRLF),
+            "cr" => Ok(Self::CR),
+            _ => Err(format!("Unrecognized line ending style: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(LineEndingStyle);
+
+/// A style of braces to use for generating code.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Braces {
+    SameLine,
+    NextLine,
+}
+
+impl FromStr for Braces {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Braces, Self::Err> {
+        match s {
+            "SameLine" => Ok(Braces::SameLine),
+            "same_line" => Ok(Braces::SameLine),
+            "NextLine" => Ok(Braces::NextLine),
+            "next_line" => Ok(Braces::NextLine),
+            _ => Err(format!("Unrecognized Braces: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(Braces);
+
+/// A type of layout to use when generating long lines of code.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Layout {
+    Horizontal,
+    Vertical,
+    Auto,
+}
+
+impl FromStr for Layout {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Layout, Self::Err> {
+        match s {
+            "Horizontal" => Ok(Layout::Horizontal),
+            "horizontal" => Ok(Layout::Horizontal),
+            "Vertical" => Ok(Layout::Vertical),
+            "vertical" => Ok(Layout::Vertical),
+            "Auto" => Ok(Layout::Auto),
+            "auto" => Ok(Layout::Auto),
+            _ => Err(format!("Unrecognized Layout: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(Layout);
+
+/// How the comments containing documentation should be styled.
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub enum DocumentationStyle {
+    C,
+    C99,
+    Doxy,
+    Cxx,
+    Auto,
+}
+
+impl FromStr for DocumentationStyle {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<DocumentationStyle, Self::Err> {
+        match s.to_lowercase().as_ref() {
+            "c" => Ok(DocumentationStyle::C),
+            "c99" => Ok(DocumentationStyle::C99),
+            "cxx" => Ok(DocumentationStyle::Cxx),
+            "c++" => Ok(DocumentationStyle::Cxx),
+            "doxy" => Ok(DocumentationStyle::Doxy),
+            "auto" => Ok(DocumentationStyle::Auto),
+            _ => Err(format!("Unrecognized documentation style: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(DocumentationStyle);
+
+/// How much of the documentation to include in the header file.
+#[derive(Debug, Clone, Copy)]
+pub enum DocumentationLength {
+    Short,
+    Full,
+}
+
+impl FromStr for DocumentationLength {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<DocumentationLength, Self::Err> {
+        match s.to_lowercase().as_ref() {
+            "short" => Ok(DocumentationLength::Short),
+            "full" => Ok(DocumentationLength::Full),
+            _ => Err(format!("Unrecognized documentation style: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(DocumentationLength);
+
+/// A style of Style to use when generating structs and enums.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+pub enum Style {
+    #[default]
+    Both,
+    Tag,
+    Type,
+}
+
+impl Style {
+    pub fn generate_tag(self) -> bool {
+        match self {
+            Style::Both | Style::Tag => true,
+            Style::Type => false,
+        }
+    }
+
+    pub fn generate_typedef(self) -> bool {
+        match self {
+            Style::Both | Style::Type => true,
+            Style::Tag => false,
+        }
+    }
+
+    // https://cython.readthedocs.io/en/latest/src/userguide/external_C_code.html#styles-of-struct-union-and-enum-declaration
+    pub fn cython_def(self) -> &'static str {
+        if self.generate_tag() {
+            "cdef "
+        } else {
+            "ctypedef "
+        }
+    }
+}
+
+impl FromStr for Style {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Style, Self::Err> {
+        match s {
+            "Both" => Ok(Style::Both),
+            "both" => Ok(Style::Both),
+            "Tag" => Ok(Style::Tag),
+            "tag" => Ok(Style::Tag),
+            "Type" => Ok(Style::Type),
+            "type" => Ok(Style::Type),
+            _ => Err(format!("Unrecognized Style: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(Style);
+
+/// Different item types that we can generate and filter.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ItemType {
+    Constants,
+    Globals,
+    Enums,
+    Structs,
+    Unions,
+    Typedefs,
+    OpaqueItems,
+    Functions,
+}
+
+impl FromStr for ItemType {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use self::ItemType::*;
+        Ok(match &*s.to_lowercase() {
+            "constants" => Constants,
+            "globals" => Globals,
+            "enums" => Enums,
+            "structs" => Structs,
+            "unions" => Unions,
+            "typedefs" => Typedefs,
+            "opaque" => OpaqueItems,
+            "functions" => Functions,
+            _ => return Err(format!("Unrecognized Style: '{}'.", s)),
+        })
+    }
+}
+
+deserialize_enum_str!(ItemType);
+
+/// Type which specifies the sort order of functions
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SortKey {
+    Name,
+    None,
+}
+
+impl FromStr for SortKey {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use self::SortKey::*;
+        Ok(match &*s.to_lowercase() {
+            "name" => Name,
+            "none" => None,
+            _ => return Err(format!("Unrecognized sort option: '{}'.", s)),
+        })
+    }
+}
+
+deserialize_enum_str!(SortKey);
+
+/// Settings to apply when exporting items.
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct ExportConfig {
+    /// A list of additional items not used by exported functions to include in
+    /// the generated bindings
+    pub include: Vec<String>,
+    /// A list of items to not include in the generated bindings
+    pub exclude: Vec<String>,
+    /// Table of name conversions to apply to item names
+    pub rename: HashMap<String, String>,
+    /// Table of raw strings to prepend to the body of items.
+    pub pre_body: HashMap<String, String>,
+    /// Table of raw strings to append to the body of items.
+    pub body: HashMap<String, String>,
+    /// A prefix to add before the name of every item
+    pub prefix: Option<String>,
+    /// Types of items to generate.
+    pub item_types: Vec<ItemType>,
+    /// Whether renaming overrides or extends prefixing.
+    pub renaming_overrides_prefixing: bool,
+    /// Mangling configuration.
+    pub mangle: MangleConfig,
+}
+
+/// Mangling-specific configuration.
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct MangleConfig {
+    /// The rename rule to apply to the type names mangled.
+    pub rename_types: RenameRule,
+    /// Remove the underscores used for name mangling.
+    pub remove_underscores: bool,
+}
+
+impl ExportConfig {
+    pub(crate) fn should_generate(&self, item_type: ItemType) -> bool {
+        self.item_types.is_empty() || self.item_types.contains(&item_type)
+    }
+
+    pub(crate) fn pre_body(&self, path: &Path) -> Option<&str> {
+        self.pre_body.get(path.name()).map(|s| s.trim_matches('\n'))
+    }
+
+    pub(crate) fn post_body(&self, path: &Path) -> Option<&str> {
+        self.body.get(path.name()).map(|s| s.trim_matches('\n'))
+    }
+
+    pub(crate) fn rename(&self, item_name: &mut String) {
+        if let Some(name) = self.rename.get(item_name) {
+            *item_name = name.clone();
+            if self.renaming_overrides_prefixing {
+                return;
+            }
+        }
+        if let Some(ref prefix) = self.prefix {
+            item_name.insert_str(0, prefix);
+        }
+    }
+}
+
+/// Settings to apply to generated types with layout modifiers.
+#[derive(Debug, Default, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct LayoutConfig {
+    /// The way to annotate C types as #[repr(packed)].
+    pub packed: Option<String>,
+    /// The way to annotate C types as #[repr(align(...))]. This is assumed to be a functional
+    /// macro which takes a single argument (the alignment).
+    pub aligned_n: Option<String>,
+}
+
+impl LayoutConfig {
+    pub(crate) fn ensure_safe_to_represent(&self, align: &ReprAlign) -> Result<(), String> {
+        match (align, &self.packed, &self.aligned_n) {
+            (ReprAlign::Packed, None, _) => Err("Cannot safely represent #[repr(packed)] type without configured 'packed' annotation.".to_string()),
+            (ReprAlign::Align(_), _, None) => Err("Cannot safely represent #[repr(aligned(...))] type without configured 'aligned_n' annotation.".to_string()),
+            _ => Ok(()),
+        }
+    }
+}
+
+/// Settings to apply to generated functions.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct FunctionConfig {
+    /// Optional text to output before each function declaration
+    pub prefix: Option<String>,
+    /// Optional text to output after each function declaration
+    pub postfix: Option<String>,
+    /// The way to annotation this function as #[must_use]
+    pub must_use: Option<String>,
+    /// The way to annotation this function as #[deprecated] without notes
+    pub deprecated: Option<String>,
+    /// The way to annotation this function as #[deprecated] with notes
+    pub deprecated_with_note: Option<String>,
+    /// The style to layout the args
+    pub args: Layout,
+    /// The rename rule to apply to function args
+    pub rename_args: RenameRule,
+    /// An optional macro to use when generating Swift function name attributes
+    pub swift_name_macro: Option<String>,
+    /// Sort key for functions
+    pub sort_by: Option<SortKey>,
+    /// Optional text to output after functions which return `!`.
+    pub no_return: Option<String>,
+}
+
+impl Default for FunctionConfig {
+    fn default() -> FunctionConfig {
+        FunctionConfig {
+            prefix: None,
+            postfix: None,
+            must_use: None,
+            deprecated: None,
+            deprecated_with_note: None,
+            args: Layout::Auto,
+            rename_args: RenameRule::None,
+            swift_name_macro: None,
+            sort_by: None,
+            no_return: None,
+        }
+    }
+}
+
+impl FunctionConfig {
+    pub(crate) fn prefix(&self, annotations: &AnnotationSet) -> Option<String> {
+        if let Some(x) = annotations.atom("prefix") {
+            return x;
+        }
+        self.prefix.clone()
+    }
+
+    pub(crate) fn postfix(&self, annotations: &AnnotationSet) -> Option<String> {
+        if let Some(x) = annotations.atom("postfix") {
+            return x;
+        }
+        self.postfix.clone()
+    }
+}
+
+/// Settings to apply to generated structs.
+#[derive(Debug, Default, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct StructConfig {
+    /// The rename rule to apply to the name of struct fields
+    pub rename_fields: RenameRule,
+    /// Whether to generate a constructor for the struct (which takes
+    /// arguments to initialize all the members)
+    pub derive_constructor: bool,
+    /// Whether to generate a piecewise equality operator
+    pub derive_eq: bool,
+    /// Whether to generate a piecewise inequality operator
+    pub derive_neq: bool,
+    /// Whether to generate a less than operator on structs with one field
+    pub derive_lt: bool,
+    /// Whether to generate a less than or equal to operator on structs with one field
+    pub derive_lte: bool,
+    /// Whether to generate a greater than operator on structs with one field
+    pub derive_gt: bool,
+    /// Whether to generate a greater than or equal to operator on structs with one field
+    pub derive_gte: bool,
+    /// Whether to generate a ostream serializer for the struct
+    pub derive_ostream: bool,
+    /// Whether associated constants should be in the body. Only applicable to
+    /// non-transparent structs, and in C++-only.
+    pub associated_constants_in_body: bool,
+    /// The way to annotate this struct as #[must_use].
+    pub must_use: Option<String>,
+    /// The way to annotation this function as #[deprecated] without notes
+    pub deprecated: Option<String>,
+    /// The way to annotation this function as #[deprecated] with notes
+    pub deprecated_with_note: Option<String>,
+}
+
+impl StructConfig {
+    pub(crate) fn derive_constructor(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-constructor") {
+            return x;
+        }
+        self.derive_constructor
+    }
+    pub(crate) fn derive_eq(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-eq") {
+            return x;
+        }
+        self.derive_eq
+    }
+    pub(crate) fn derive_neq(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-neq") {
+            return x;
+        }
+        self.derive_neq
+    }
+    pub(crate) fn derive_lt(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-lt") {
+            return x;
+        }
+        self.derive_lt
+    }
+    pub(crate) fn derive_lte(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-lte") {
+            return x;
+        }
+        self.derive_lte
+    }
+    pub(crate) fn derive_gt(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-gt") {
+            return x;
+        }
+        self.derive_gt
+    }
+    pub(crate) fn derive_gte(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-gte") {
+            return x;
+        }
+        self.derive_gte
+    }
+    pub(crate) fn derive_ostream(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-ostream") {
+            return x;
+        }
+        self.derive_ostream
+    }
+}
+
+/// Settings to apply to generated enums.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct EnumConfig {
+    /// The rename rule to apply to the name of enum variants
+    pub rename_variants: RenameRule,
+    /// The rename rule to apply to the names of the union fields in C/C++
+    /// generated from the Rust enum. Applied before rename_variants
+    /// rename rule. Defaults to SnakeCase.
+    pub rename_variant_name_fields: RenameRule,
+    /// Whether to add a `Sentinel` value at the end of every enum
+    /// This is useful in Gecko for IPC serialization
+    pub add_sentinel: bool,
+    /// Whether the enum variants should be prefixed with the enum name
+    pub prefix_with_name: bool,
+    /// Whether to generate static `::X(..)` constructors and `IsX()`
+    /// methods for tagged enums.
+    pub derive_helper_methods: bool,
+    /// Whether to generate `AsX() const` methods for tagged enums.
+    pub derive_const_casts: bool,
+    /// Whether to generate `AsX()` methods for tagged enums.
+    pub derive_mut_casts: bool,
+    /// The name of the macro to use for `derive_{const,mut}casts`. If custom, you're
+    /// responsible to provide the necessary header, otherwise `assert` will be
+    /// used, and `<cassert>` will be included.
+    pub cast_assert_name: Option<String>,
+    /// The way to annotation this enum as #[must_use].
+    pub must_use: Option<String>,
+    /// The way to annotation this function as #[deprecated] without notes
+    pub deprecated: Option<String>,
+    /// The way to annotation this function as #[deprecated] with notes
+    pub deprecated_with_note: Option<String>,
+    /// Whether to generate destructors of tagged enums.
+    pub derive_tagged_enum_destructor: bool,
+    /// Whether to generate copy-constructors of tagged enums.
+    pub derive_tagged_enum_copy_constructor: bool,
+    /// Whether to generate copy-assignment operators of tagged enums.
+    ///
+    /// This is only generated if a copy constructor for the same tagged enum is
+    /// generated as well.
+    pub derive_tagged_enum_copy_assignment: bool,
+    /// Whether to generate a ostream serializer for the struct
+    pub derive_ostream: bool,
+    /// Declare the enum as an enum class.
+    /// Only relevant when targeting C++.
+    pub enum_class: bool,
+    /// Whether to generate empty, private default-constructors for tagged
+    /// enums.
+    pub private_default_tagged_enum_constructor: bool,
+}
+
+impl Default for EnumConfig {
+    fn default() -> EnumConfig {
+        EnumConfig {
+            rename_variants: RenameRule::None,
+            rename_variant_name_fields: RenameRule::SnakeCase,
+            add_sentinel: false,
+            prefix_with_name: false,
+            derive_helper_methods: false,
+            derive_const_casts: false,
+            derive_mut_casts: false,
+            cast_assert_name: None,
+            must_use: None,
+            deprecated: None,
+            deprecated_with_note: None,
+            derive_tagged_enum_destructor: false,
+            derive_tagged_enum_copy_constructor: false,
+            derive_tagged_enum_copy_assignment: false,
+            derive_ostream: false,
+            enum_class: true,
+            private_default_tagged_enum_constructor: false,
+        }
+    }
+}
+
+impl EnumConfig {
+    pub(crate) fn add_sentinel(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("add-sentinel") {
+            return x;
+        }
+        self.add_sentinel
+    }
+    pub(crate) fn derive_helper_methods(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-helper-methods") {
+            return x;
+        }
+        self.derive_helper_methods
+    }
+    pub(crate) fn derive_const_casts(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-const-casts") {
+            return x;
+        }
+        self.derive_const_casts
+    }
+    pub(crate) fn derive_mut_casts(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-mut-casts") {
+            return x;
+        }
+        self.derive_mut_casts
+    }
+    pub(crate) fn derive_tagged_enum_destructor(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-tagged-enum-destructor") {
+            return x;
+        }
+        self.derive_tagged_enum_destructor
+    }
+    pub(crate) fn derive_tagged_enum_copy_constructor(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-tagged-enum-copy-constructor") {
+            return x;
+        }
+        self.derive_tagged_enum_copy_constructor
+    }
+    pub(crate) fn derive_tagged_enum_copy_assignment(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-tagged-enum-copy-assignment") {
+            return x;
+        }
+        self.derive_tagged_enum_copy_assignment
+    }
+    pub(crate) fn derive_ostream(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("derive-ostream") {
+            return x;
+        }
+        self.derive_ostream
+    }
+    pub(crate) fn enum_class(&self, annotations: &AnnotationSet) -> bool {
+        if let Some(x) = annotations.bool("enum-class") {
+            return x;
+        }
+        self.enum_class
+    }
+    pub(crate) fn private_default_tagged_enum_constructor(
+        &self,
+        annotations: &AnnotationSet,
+    ) -> bool {
+        if let Some(x) = annotations.bool("private-default-tagged-enum-constructor") {
+            return x;
+        }
+        self.private_default_tagged_enum_constructor
+    }
+}
+
+/// Settings to apply to generated constants.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct ConstantConfig {
+    /// Whether a generated constant can be a static const in C++ mode.
+    pub allow_static_const: bool,
+    /// Whether a generated constant should be constexpr in C++ mode.
+    pub allow_constexpr: bool,
+    /// Sort key for constants
+    pub sort_by: Option<SortKey>,
+}
+
+impl Default for ConstantConfig {
+    fn default() -> ConstantConfig {
+        ConstantConfig {
+            allow_static_const: true,
+            allow_constexpr: true,
+            sort_by: None,
+        }
+    }
+}
+
+/// Settings for custom macro expansion.
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct MacroExpansionConfig {
+    /// Whether the `bitflags` macro should be expanded.
+    pub bitflags: bool,
+}
+
+/// Controls which Cargo profile is used for macro expansion.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Profile {
+    Debug,
+    Release,
+}
+
+impl FromStr for Profile {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Profile, Self::Err> {
+        match s {
+            "debug" | "Debug" => Ok(Profile::Debug),
+            "release" | "Release" => Ok(Profile::Release),
+            _ => Err(format!("Unrecognized Profile: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(Profile);
+
+/// Settings to apply when running `rustc -Zunpretty=expanded`
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct ParseExpandConfig {
+    /// The names of crates to parse with `rustc -Zunpretty=expanded`
+    pub crates: Vec<String>,
+    /// Whether to enable all the features when expanding.
+    pub all_features: bool,
+    /// Whether to use the default feature set when expanding.
+    pub default_features: bool,
+    /// List of features to use when expanding. Combines with `default_features` like in
+    /// `Cargo.toml`.
+    pub features: Option<Vec<String>>,
+    /// Controls whether or not to pass `--release` when expanding.
+    pub profile: Profile,
+}
+
+impl Default for ParseExpandConfig {
+    fn default() -> ParseExpandConfig {
+        ParseExpandConfig {
+            crates: Vec::new(),
+            all_features: false,
+            default_features: true,
+            features: None,
+            profile: Profile::Debug,
+        }
+    }
+}
+
+// Backwards-compatibility deserializer for ParseExpandConfig. This allows accepting both the
+// simple `expand = ["crate"]` and the more complex `expand = {"crates": ["crate"],
+// "default_features": false}` format for the `expand` key.
+//
+// Note that one (major) difference between the two forms is that, for backwards-compatibility
+// reasons, the `expand = ["crate"]` form will enable the `--all-features` flag by default while
+// the `expand = {"crates": ["crate"]}` form will use the default feature set by default.
+fn retrocomp_parse_expand_config_deserialize<'de, D: Deserializer<'de>>(
+    deserializer: D,
+) -> Result<ParseExpandConfig, D::Error> {
+    struct ParseExpandVisitor;
+
+    impl<'de> Visitor<'de> for ParseExpandVisitor {
+        type Value = ParseExpandConfig;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a map or sequence of string")
+        }
+
+        fn visit_seq<A: SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> {
+            let crates =
+                <Vec<String> as Deserialize>::deserialize(SeqAccessDeserializer::new(seq))?;
+            Ok(ParseExpandConfig {
+                crates,
+                all_features: true,
+                default_features: true,
+                features: None,
+                profile: Profile::Debug,
+            })
+        }
+
+        fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
+            <ParseExpandConfig as Deserialize>::deserialize(MapAccessDeserializer::new(map))
+        }
+    }
+
+    deserializer.deserialize_any(ParseExpandVisitor)
+}
+
+/// Settings to apply when parsing.
+#[derive(Debug, Default, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct ParseConfig {
+    /// Whether to parse dependencies when generating bindings. When this is true,
+    /// each dependent crate is found using a combination of `cargo metadata` and
+    /// `Cargo.lock`. To further control this behavior, crates can be whitelisted or
+    /// blacklisted using `include` and `exclude` respectively. Additionally in cases
+    /// where crates have types to expose in bindings hidden in macros, a crate can
+    /// be marked in `expand` and `cargo expand` will be used to expand the macros
+    /// before parsing. A crate marked in `expand` doesn't need to be added to any
+    /// whitelist.
+    pub parse_deps: bool,
+    /// An optional whitelist of names of crates to parse
+    pub include: Option<Vec<String>>,
+    /// The names of crates to not parse
+    pub exclude: Vec<String>,
+    /// The configuration options for `rustc -Zunpretty=expanded`
+    #[serde(deserialize_with = "retrocomp_parse_expand_config_deserialize")]
+    pub expand: ParseExpandConfig,
+    /// Whether to use a new temporary target directory when running `rustc -Zunpretty=expanded`.
+    /// This may be required for some build processes.
+    pub clean: bool,
+    /// List of crate names which generate consts, statics, and fns. By default
+    /// no dependent crates generate them.
+    pub extra_bindings: Vec<String>,
+}
+
+impl ParseConfig {
+    pub(crate) fn should_generate_top_level_item(
+        &self,
+        crate_name: &str,
+        binding_crate_name: &str,
+    ) -> bool {
+        if crate_name == binding_crate_name {
+            // Always generate items for the binding crate.
+            return true;
+        }
+
+        self.extra_bindings.iter().any(|dep| dep == crate_name)
+    }
+}
+
+/// Settings to apply to pointers
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct PtrConfig {
+    /// Optional attribute to apply to pointers that are required to not be null
+    pub non_null_attribute: Option<String>,
+}
+
+/// Settings specific to Cython bindings.
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct CythonConfig {
+    /// Header specified in the top level `cdef extern from header:` declaration.
+    pub header: Option<String>,
+    /// `from module cimport name1, name2, ...` declarations added in the same place
+    /// where you'd get includes in C.
+    pub cimports: BTreeMap<String, Vec<String>>,
+}
+
+/// A collection of settings to customize the generated bindings.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct Config {
+    /// Optional text to output at the beginning of the file
+    pub header: Option<String>,
+    /// A list of additional includes to put at the beginning of the generated header
+    pub includes: Vec<String>,
+    /// A list of additional system includes to put at the beginning of the generated header
+    pub sys_includes: Vec<String>,
+    /// Optional verbatim code added after the include blocks
+    pub after_includes: Option<String>,
+    /// Optional text to output at the end of the file
+    pub trailer: Option<String>,
+    /// Optional name to use for an include guard
+    pub include_guard: Option<String>,
+    /// Add a `#pragma once` guard
+    pub pragma_once: bool,
+    /// Generates no includes at all. Overrides all other include options
+    ///
+    /// This option is useful when using cbindgen with tools such as python's cffi which
+    /// doesn't understand include directives
+    pub no_includes: bool,
+    /// Optional text to output at major sections to deter manual editing
+    pub autogen_warning: Option<String>,
+    /// Include a comment with the version of cbindgen used to generate the file
+    pub include_version: bool,
+    /// An optional name for the root namespace. Only applicable when language="C++"
+    pub namespace: Option<String>,
+    /// An optional list of namespaces. Only applicable when language="C++"
+    pub namespaces: Option<Vec<String>>,
+    /// An optional list of namespaces to declare as using. Only applicable when language="C++"
+    pub using_namespaces: Option<Vec<String>>,
+    /// The style to use for braces
+    pub braces: Braces,
+    /// The preferred length of a line, used for auto breaking function arguments
+    pub line_length: usize,
+    /// The amount of spaces in a tab
+    pub tab_width: usize,
+    /// The type of line endings to generate
+    pub line_endings: LineEndingStyle,
+    /// The language to output bindings for
+    pub language: Language,
+    /// Include preprocessor defines in C bindings to ensure C++ compatibility
+    pub cpp_compat: bool,
+    /// The style to declare structs, enums and unions in for C
+    pub style: Style,
+    /// Default sort key for functions and constants.
+    pub sort_by: SortKey,
+    /// If this option is true `usize` and `isize` will be converted into `size_t` and `ptrdiff_t`
+    /// instead of `uintptr_t` and `intptr_t` respectively.
+    pub usize_is_size_t: bool,
+    /// The configuration options for parsing
+    pub parse: ParseConfig,
+    /// The configuration options for exporting
+    pub export: ExportConfig,
+    /// The configuration options for macros.
+    pub macro_expansion: MacroExpansionConfig,
+    /// The configuration options for type layouts.
+    pub layout: LayoutConfig,
+    /// The configuration options for functions
+    #[serde(rename = "fn")]
+    pub function: FunctionConfig,
+    /// The configuration options for structs
+    #[serde(rename = "struct")]
+    pub structure: StructConfig,
+    /// The configuration options for enums
+    #[serde(rename = "enum")]
+    pub enumeration: EnumConfig,
+    /// The configuration options for constants
+    #[serde(rename = "const")]
+    pub constant: ConstantConfig,
+    /// Preprocessor defines to use when generating #ifdef's for #[cfg]
+    pub defines: HashMap<String, String>,
+    /// Include doc comments from Rust as documentation
+    pub documentation: bool,
+    /// How documentation comments should be styled.
+    pub documentation_style: DocumentationStyle,
+    /// How much of the documentation should be output for each item.
+    pub documentation_length: DocumentationLength,
+    /// Configuration options for pointers
+    #[serde(rename = "ptr")]
+    pub pointer: PtrConfig,
+    /// Only download sources for dependencies needed for the target platform.
+    ///
+    /// By default, cbindgen will fetch sources for dependencies used on any platform so that if a
+    /// type is defined in terms of a type from a dependency on another target (probably behind a
+    /// `#[cfg]`), cbindgen will be able to generate the appropriate binding as it can see the
+    /// nested type's definition. However, this makes calling cbindgen slower, as it may have to
+    /// download a number of additional dependencies.
+    ///
+    /// As an example, consider this Cargo.toml:
+    ///
+    /// ```toml
+    /// [target.'cfg(windows)'.dependencies]
+    /// windows = "0.7"
+    /// ```
+    ///
+    /// with this declaration in one of the `.rs` files that cbindgen is asked to generate bindings
+    /// for:
+    ///
+    /// ```rust,ignore
+    /// #[cfg(windows)]
+    /// pub struct Error(windows::ErrorCode);
+    /// ```
+    ///
+    /// With the default value (`false`), cbindgen will download the `windows` dependency even when
+    /// not compiling for Windows, and will thus be able to generate the binding for `Error`
+    /// (behind a `#define`).
+    ///
+    /// If this value is instead to `true`, cbindgen will _not_ download the `windows` dependency
+    /// if it's not compiling for Windows, but will also fail to generate a Windows binding for
+    /// `Error` as it does not know the definition for `ErrorCode`.
+    ///
+    /// The target can be chosen via the `TARGET` environment variable (if used
+    /// via the CLI, when ran from a build script cargo sets this variable
+    /// appropriately).
+    pub only_target_dependencies: bool,
+    /// Configuration options specific to Cython.
+    pub cython: CythonConfig,
+    #[serde(skip)]
+    pub(crate) config_path: Option<StdPathBuf>,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            header: None,
+            includes: Vec::new(),
+            sys_includes: Vec::new(),
+            after_includes: None,
+            trailer: None,
+            include_guard: None,
+            pragma_once: false,
+            autogen_warning: None,
+            include_version: false,
+            no_includes: false,
+            namespace: None,
+            namespaces: None,
+            using_namespaces: None,
+            braces: Braces::SameLine,
+            line_length: 100,
+            tab_width: 2,
+            line_endings: LineEndingStyle::default(),
+            language: Language::Cxx,
+            cpp_compat: false,
+            style: Style::default(),
+            usize_is_size_t: false,
+            sort_by: SortKey::None,
+            macro_expansion: Default::default(),
+            parse: ParseConfig::default(),
+            export: ExportConfig::default(),
+            layout: LayoutConfig::default(),
+            function: FunctionConfig::default(),
+            structure: StructConfig::default(),
+            enumeration: EnumConfig::default(),
+            constant: ConstantConfig::default(),
+            defines: HashMap::new(),
+            documentation: true,
+            documentation_style: DocumentationStyle::Auto,
+            documentation_length: DocumentationLength::Full,
+            pointer: PtrConfig::default(),
+            only_target_dependencies: false,
+            cython: CythonConfig::default(),
+            config_path: None,
+        }
+    }
+}
+
+impl Config {
+    pub(crate) fn cpp_compatible_c(&self) -> bool {
+        self.language == Language::C && self.cpp_compat
+    }
+
+    pub(crate) fn include_guard(&self) -> Option<&str> {
+        if self.language == Language::Cython {
+            None
+        } else {
+            self.include_guard.as_deref()
+        }
+    }
+
+    pub(crate) fn includes(&self) -> &[String] {
+        if self.language == Language::Cython {
+            &[]
+        } else {
+            &self.includes
+        }
+    }
+
+    pub(crate) fn sys_includes(&self) -> &[String] {
+        if self.language == Language::Cython {
+            &[]
+        } else {
+            &self.sys_includes
+        }
+    }
+
+    pub fn from_file<P: AsRef<StdPath>>(file_name: P) -> Result<Config, String> {
+        let config_text = fs::read_to_string(file_name.as_ref()).map_err(|_| {
+            format!(
+                "Couldn't open config file: {}.",
+                file_name.as_ref().display()
+            )
+        })?;
+
+        let mut config = toml::from_str::<Config>(&config_text)
+            .map_err(|e| format!("Couldn't parse config file: {}.", e))?;
+        config.config_path = Some(StdPathBuf::from(file_name.as_ref()));
+        Ok(config)
+    }
+
+    pub fn from_root_or_default<P: AsRef<StdPath>>(root: P) -> Config {
+        let c = root.as_ref().join("cbindgen.toml");
+
+        if c.exists() {
+            Config::from_file(c).unwrap()
+        } else {
+            Config::default()
+        }
+    }
+}
diff --git a/src/bindgen/declarationtyperesolver.rs b/src/bindgen/declarationtyperesolver.rs
new file mode 100644
index 0000000..e72761e
--- /dev/null
+++ b/src/bindgen/declarationtyperesolver.rs
@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::bindgen::ir::Path;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+
+impl DeclarationType {
+    pub fn to_str(self) -> &'static str {
+        match self {
+            DeclarationType::Struct => "struct",
+            DeclarationType::Enum => "enum",
+            DeclarationType::Union => "union",
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
+pub enum DeclarationType {
+    Struct,
+    Enum,
+    Union,
+}
+
+#[derive(Default)]
+pub struct DeclarationTypeResolver {
+    types: HashMap<Path, Option<DeclarationType>>,
+}
+
+impl DeclarationTypeResolver {
+    fn insert(&mut self, path: &Path, ty: Option<DeclarationType>) {
+        if let Entry::Vacant(vacant_entry) = self.types.entry(path.clone()) {
+            vacant_entry.insert(ty);
+        }
+    }
+
+    pub fn add_enum(&mut self, path: &Path) {
+        self.insert(path, Some(DeclarationType::Enum));
+    }
+
+    pub fn add_struct(&mut self, path: &Path) {
+        self.insert(path, Some(DeclarationType::Struct));
+    }
+
+    pub fn add_union(&mut self, path: &Path) {
+        self.insert(path, Some(DeclarationType::Union));
+    }
+
+    pub fn add_none(&mut self, path: &Path) {
+        self.insert(path, None);
+    }
+
+    pub fn type_for(&self, path: &Path) -> Option<DeclarationType> {
+        *self.types.get(path)?
+    }
+}
diff --git a/src/bindgen/dependencies.rs b/src/bindgen/dependencies.rs
new file mode 100644
index 0000000..6a98738
--- /dev/null
+++ b/src/bindgen/dependencies.rs
@@ -0,0 +1,46 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::cmp::Ordering;
+use std::collections::HashSet;
+
+use crate::bindgen::ir::{ItemContainer, Path};
+
+/// A dependency list is used for gathering what order to output the types.
+#[derive(Default)]
+pub struct Dependencies {
+    pub order: Vec<ItemContainer>,
+    pub items: HashSet<Path>,
+}
+
+impl Dependencies {
+    pub fn new() -> Dependencies {
+        Dependencies {
+            order: Vec::new(),
+            items: HashSet::new(),
+        }
+    }
+
+    pub fn sort(&mut self) {
+        // Sort untagged enums and opaque structs into their own layers because they don't
+        // depend on each other or anything else.
+        let ordering = |a: &ItemContainer, b: &ItemContainer| match (a, b) {
+            (ItemContainer::Enum(x), ItemContainer::Enum(y))
+                if x.tag.is_none() && y.tag.is_none() =>
+            {
+                x.path.cmp(&y.path)
+            }
+            (ItemContainer::Enum(x), _) if x.tag.is_none() => Ordering::Less,
+            (_, ItemContainer::Enum(x)) if x.tag.is_none() => Ordering::Greater,
+
+            (ItemContainer::OpaqueItem(x), ItemContainer::OpaqueItem(y)) => x.path.cmp(&y.path),
+            (&ItemContainer::OpaqueItem(_), _) => Ordering::Less,
+            (_, &ItemContainer::OpaqueItem(_)) => Ordering::Greater,
+
+            _ => Ordering::Equal,
+        };
+
+        self.order.sort_by(ordering);
+    }
+}
diff --git a/src/bindgen/error.rs b/src/bindgen/error.rs
new file mode 100644
index 0000000..e4002f6
--- /dev/null
+++ b/src/bindgen/error.rs
@@ -0,0 +1,88 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::error;
+use std::fmt;
+
+pub use crate::bindgen::cargo::cargo_expand::Error as CargoExpandError;
+pub use crate::bindgen::cargo::cargo_metadata::Error as CargoMetadataError;
+pub use crate::bindgen::cargo::cargo_toml::Error as CargoTomlError;
+pub use syn::parse::Error as ParseError;
+
+#[derive(Debug)]
+#[allow(clippy::enum_variant_names)]
+pub enum Error {
+    CargoMetadata(String, CargoMetadataError),
+    CargoToml(String, CargoTomlError),
+    CargoExpand(String, CargoExpandError),
+    ParseSyntaxError {
+        crate_name: String,
+        src_path: String,
+        error: ParseError,
+    },
+    ParseCannotOpenFile {
+        crate_name: String,
+        src_path: String,
+    },
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Error::CargoMetadata(ref path, ref error) => write!(
+                f,
+                "Couldn't execute `cargo metadata` with manifest {:?}: {:?}",
+                path, error
+            ),
+            Error::CargoToml(ref path, ref error) => {
+                write!(f, "Couldn't load manifest file {:?}: {:?}", path, error)
+            }
+            Error::CargoExpand(ref crate_name, ref error) => write!(
+                f,
+                "Parsing crate `{}`: couldn't run `cargo rustc -Zunpretty=expanded`: {:?}",
+                crate_name, error
+            ),
+            Error::ParseSyntaxError {
+                ref crate_name,
+                ref src_path,
+                ref error,
+            } => {
+                write!(
+                    f,
+                    "Parsing crate `{}`:`{}`:\n{:?}",
+                    crate_name, src_path, error
+                )?;
+
+                if !src_path.is_empty() {
+                    write!(
+                        f,
+                        "\nTry running `rustc -Z parse-only {}` to see a nicer error message",
+                        src_path,
+                    )?
+                }
+                Ok(())
+            }
+            Error::ParseCannotOpenFile {
+                ref crate_name,
+                ref src_path,
+            } => write!(
+                f,
+                "Parsing crate `{}`: cannot open file `{}`.",
+                crate_name, src_path
+            ),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            Error::CargoMetadata(_, ref error) => Some(error),
+            Error::CargoToml(_, ref error) => Some(error),
+            Error::CargoExpand(_, ref error) => Some(error),
+            Error::ParseSyntaxError { ref error, .. } => Some(error),
+            Error::ParseCannotOpenFile { .. } => None,
+        }
+    }
+}
diff --git a/src/bindgen/ir/annotation.rs b/src/bindgen/ir/annotation.rs
new file mode 100644
index 0000000..48e3e4b
--- /dev/null
+++ b/src/bindgen/ir/annotation.rs
@@ -0,0 +1,217 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::borrow::Cow;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::str::FromStr;
+
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::utilities::SynAttributeHelpers;
+
+// A system for specifying properties on items. Annotations are
+// given through document comments and parsed by this code.
+//
+// An annotation is in the form cbindgen:PROPERTY=VALUE
+// Where PROPERTY depends on the item
+// Where VALUE can be
+//  * list - [Item1, Item2, Item3, ...]
+//  * atom - Foo
+//  * bool - true,false
+// Examples:
+//  * cbindgen:field-names=[mHandle, mNamespace]
+//  * cbindgen:function-postfix=WR_DESTRUCTOR_SAFE
+
+/// A value specified by an annotation.
+#[derive(Debug, Clone)]
+pub enum AnnotationValue {
+    List(Vec<String>),
+    Atom(Option<String>),
+    Bool(bool),
+}
+
+/// A set of annotations specified by a document comment.
+#[derive(Debug, Default, Clone)]
+pub struct AnnotationSet {
+    annotations: HashMap<String, AnnotationValue>,
+    pub must_use: bool,
+    pub deprecated: Option<String>,
+}
+
+pub enum DeprecatedNoteKind {
+    Function,
+    Struct,
+    Enum,
+}
+
+impl AnnotationSet {
+    pub fn new() -> AnnotationSet {
+        AnnotationSet {
+            annotations: HashMap::new(),
+            must_use: false,
+            deprecated: None,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.annotations.is_empty() && !self.must_use
+    }
+
+    pub(crate) fn must_use(&self, config: &Config) -> bool {
+        self.must_use && config.language != Language::Cython
+    }
+
+    pub(crate) fn deprecated_note<'c>(
+        &self,
+        config: &'c Config,
+        kind: DeprecatedNoteKind,
+    ) -> Option<Cow<'c, str>> {
+        let note = self.deprecated.as_deref()?;
+
+        if config.language == Language::Cython {
+            return None;
+        }
+
+        if note.is_empty() {
+            return Some(Cow::Borrowed(match kind {
+                DeprecatedNoteKind::Enum => config.enumeration.deprecated.as_deref()?,
+                DeprecatedNoteKind::Function => config.function.deprecated.as_deref()?,
+                DeprecatedNoteKind::Struct => config.structure.deprecated.as_deref()?,
+            }));
+        }
+
+        let format = match kind {
+            DeprecatedNoteKind::Enum => &config.enumeration.deprecated_with_note,
+            DeprecatedNoteKind::Function => &config.function.deprecated_with_note,
+            DeprecatedNoteKind::Struct => &config.structure.deprecated_with_note,
+        }
+        .as_ref()?;
+        Some(Cow::Owned(format.replace("{}", &format!("{:?}", note))))
+    }
+
+    pub fn load(attrs: &[syn::Attribute]) -> Result<AnnotationSet, String> {
+        let lines = attrs.get_comment_lines();
+        let lines: Vec<&str> = lines
+            .iter()
+            .filter_map(|line| {
+                let line = line.trim_start();
+                if !line.starts_with("cbindgen:") {
+                    return None;
+                }
+
+                Some(line)
+            })
+            .collect();
+
+        let must_use = attrs.has_attr_word("must_use");
+        let deprecated = attrs.find_deprecated_note();
+        let mut annotations = HashMap::new();
+
+        // Look at each line for an annotation
+        for line in lines {
+            debug_assert!(line.starts_with("cbindgen:"));
+
+            // Remove the "cbindgen:" prefix
+            let annotation = &line[9..];
+
+            // Split the annotation in two
+            let parts: Vec<&str> = annotation.split('=').map(|x| x.trim()).collect();
+
+            if parts.len() > 2 {
+                return Err(format!("Couldn't parse {}.", line));
+            }
+
+            // Grab the name that this annotation is modifying
+            let name = parts[0];
+
+            // If the annotation only has a name, assume it's setting a bool flag
+            if parts.len() == 1 {
+                annotations.insert(name.to_string(), AnnotationValue::Bool(true));
+                continue;
+            }
+
+            // Parse the value we're setting the name to
+            let value = parts[1];
+
+            if let Some(x) = parse_list(value) {
+                annotations.insert(name.to_string(), AnnotationValue::List(x));
+                continue;
+            }
+            if let Ok(x) = value.parse::<bool>() {
+                annotations.insert(name.to_string(), AnnotationValue::Bool(x));
+                continue;
+            }
+            annotations.insert(
+                name.to_string(),
+                if value.is_empty() {
+                    AnnotationValue::Atom(None)
+                } else {
+                    AnnotationValue::Atom(Some(value.to_string()))
+                },
+            );
+        }
+
+        Ok(AnnotationSet {
+            annotations,
+            must_use,
+            deprecated,
+        })
+    }
+
+    /// Adds an annotation value if none is specified.
+    pub fn add_default(&mut self, name: &str, value: AnnotationValue) {
+        if let Entry::Vacant(e) = self.annotations.entry(name.to_string()) {
+            e.insert(value);
+        }
+    }
+
+    pub fn list(&self, name: &str) -> Option<Vec<String>> {
+        match self.annotations.get(name) {
+            Some(AnnotationValue::List(x)) => Some(x.clone()),
+            _ => None,
+        }
+    }
+    pub fn atom(&self, name: &str) -> Option<Option<String>> {
+        match self.annotations.get(name) {
+            Some(AnnotationValue::Atom(x)) => Some(x.clone()),
+            _ => None,
+        }
+    }
+    pub fn bool(&self, name: &str) -> Option<bool> {
+        match self.annotations.get(name) {
+            Some(AnnotationValue::Bool(x)) => Some(*x),
+            _ => None,
+        }
+    }
+
+    pub fn parse_atom<T>(&self, name: &str) -> Option<T>
+    where
+        T: Default + FromStr,
+    {
+        match self.annotations.get(name) {
+            Some(AnnotationValue::Atom(x)) => Some(
+                x.as_ref()
+                    .map_or(T::default(), |y| y.parse::<T>().ok().unwrap()),
+            ),
+            _ => None,
+        }
+    }
+}
+
+/// Parse lists like "[x, y, z]". This is not implemented efficiently or well.
+fn parse_list(list: &str) -> Option<Vec<String>> {
+    if list.len() < 2 {
+        return None;
+    }
+
+    match (list.chars().next(), list.chars().last()) {
+        (Some('['), Some(']')) => Some(
+            list[1..list.len() - 1]
+                .split(',')
+                .map(|x| x.trim().to_string())
+                .collect(),
+        ),
+        _ => None,
+    }
+}
diff --git a/src/bindgen/ir/cfg.rs b/src/bindgen/ir/cfg.rs
new file mode 100644
index 0000000..e8aa412
--- /dev/null
+++ b/src/bindgen/ir/cfg.rs
@@ -0,0 +1,365 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::fmt;
+use std::io::Write;
+
+use crate::bindgen::cargo::cargo_metadata::Dependency;
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::writer::SourceWriter;
+
+#[derive(PartialEq, Eq)]
+enum DefineKey<'a> {
+    Boolean(&'a str),
+    Named(&'a str, &'a str),
+}
+
+impl<'a> DefineKey<'a> {
+    fn load(key: &str) -> DefineKey {
+        // TODO: dirty parser
+        if !key.contains('=') {
+            return DefineKey::Boolean(key);
+        }
+
+        let mut splits = key.trim().split('=');
+
+        let name = match splits.next() {
+            Some(n) => n.trim(),
+            None => return DefineKey::Boolean(key),
+        };
+
+        let value = match splits.next() {
+            Some(v) => v.trim(),
+            None => return DefineKey::Boolean(key),
+        };
+
+        if splits.next().is_some() {
+            return DefineKey::Boolean(key);
+        }
+
+        DefineKey::Named(name, value)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Cfg {
+    Boolean(String),
+    Named(String, String),
+    Any(Vec<Cfg>),
+    All(Vec<Cfg>),
+    Not(Box<Cfg>),
+}
+
+impl fmt::Display for Cfg {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Cfg::Boolean(key) => write!(f, "{}", key),
+            Cfg::Named(key, value) => write!(f, "{} = {:?}", key, value),
+            Cfg::Any(cfgs) => {
+                write!(f, "any(")?;
+                for (index, cfg) in cfgs.iter().enumerate() {
+                    if index > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{}", cfg)?;
+                }
+                write!(f, ")")
+            }
+            Cfg::All(cfgs) => {
+                write!(f, "all(")?;
+                for (index, cfg) in cfgs.iter().enumerate() {
+                    if index > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{}", cfg)?;
+                }
+                write!(f, ")")
+            }
+            Cfg::Not(cfg) => write!(f, "not({})", cfg),
+        }
+    }
+}
+
+impl Cfg {
+    pub fn join(cfgs: &[Cfg]) -> Option<Cfg> {
+        if cfgs.is_empty() {
+            None
+        } else {
+            Some(Cfg::All(cfgs.to_owned()))
+        }
+    }
+
+    pub fn append(parent: Option<&Cfg>, child: Option<Cfg>) -> Option<Cfg> {
+        match (parent, child) {
+            (None, None) => None,
+            (None, Some(child)) => Some(child),
+            (Some(parent), None) => Some(parent.clone()),
+            (Some(parent), Some(child)) => Some(Cfg::All(vec![parent.clone(), child])),
+        }
+    }
+
+    pub fn load(attrs: &[syn::Attribute]) -> Option<Cfg> {
+        let mut configs = Vec::new();
+
+        for attr in attrs {
+            if let Ok(syn::Meta::List(syn::MetaList { path, nested, .. })) = attr.parse_meta() {
+                if !path.is_ident("cfg") || nested.len() != 1 {
+                    continue;
+                }
+
+                if let Some(config) = Cfg::load_single(nested.first().unwrap()) {
+                    configs.push(config);
+                }
+            }
+        }
+
+        match configs.len() {
+            0 => None,
+            1 => Some(configs.pop().unwrap()),
+            _ => Some(Cfg::All(configs)),
+        }
+    }
+
+    pub fn load_metadata(dependency: &Dependency) -> Option<Cfg> {
+        let target = dependency.target.as_ref()?;
+        match syn::parse_str::<syn::Meta>(target) {
+            Ok(target) => {
+                // Parsing succeeded using the #[cfg] syntax
+                if let syn::Meta::List(syn::MetaList { path, nested, .. }) = target {
+                    if !path.is_ident("cfg") || nested.len() != 1 {
+                        return None;
+                    }
+                    Cfg::load_single(nested.first().unwrap())
+                } else {
+                    None
+                }
+            }
+            Err(_) => {
+                // Parsing failed using #[cfg], this may be a literal target
+                // name
+                Cfg::load_single(&syn::NestedMeta::Lit(syn::Lit::Str(syn::LitStr::new(
+                    target,
+                    proc_macro2::Span::call_site(),
+                ))))
+            }
+        }
+    }
+
+    fn load_single(item: &syn::NestedMeta) -> Option<Cfg> {
+        Some(match *item {
+            syn::NestedMeta::Meta(syn::Meta::Path(ref path)) => {
+                Cfg::Boolean(format!("{}", path.segments.first().unwrap().ident))
+            }
+            syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
+                ref path,
+                lit: syn::Lit::Str(ref value),
+                ..
+            })) => Cfg::Named(
+                format!("{}", path.segments.first().unwrap().ident),
+                value.value(),
+            ),
+            syn::NestedMeta::Meta(syn::Meta::List(syn::MetaList {
+                ref path,
+                ref nested,
+                ..
+            })) => {
+                if path.is_ident("any") {
+                    Cfg::Any(Cfg::load_list(nested.iter())?)
+                } else if path.is_ident("all") {
+                    Cfg::All(Cfg::load_list(nested.iter())?)
+                } else if path.is_ident("not") {
+                    if nested.len() != 1 {
+                        return None;
+                    }
+
+                    Cfg::Not(Box::new(Cfg::load_single(&nested[0])?))
+                } else {
+                    return None;
+                }
+            }
+            _ => return None,
+        })
+    }
+
+    fn load_list<'a, I: Iterator<Item = &'a syn::NestedMeta>>(attrs: I) -> Option<Vec<Cfg>> {
+        let mut configs = Vec::new();
+
+        for attr in attrs {
+            configs.push(Cfg::load_single(attr)?);
+        }
+
+        if configs.is_empty() {
+            None
+        } else {
+            Some(configs)
+        }
+    }
+}
+
+pub trait ToCondition: Sized {
+    fn to_condition(&self, config: &Config) -> Option<Condition>;
+}
+
+impl ToCondition for Option<Cfg> {
+    fn to_condition(&self, config: &Config) -> Option<Condition> {
+        self.as_ref()?.to_condition(config)
+    }
+}
+
+impl ToCondition for Cfg {
+    fn to_condition(&self, config: &Config) -> Option<Condition> {
+        match *self {
+            Cfg::Boolean(ref cfg_name) => {
+                let define = config
+                    .defines
+                    .iter()
+                    .find(|(key, ..)| DefineKey::Boolean(cfg_name) == DefineKey::load(key));
+                if let Some((_, define)) = define {
+                    Some(Condition::Define(define.to_owned()))
+                } else {
+                    warn!(
+                        "Missing `[defines]` entry for `{}` in cbindgen config.",
+                        self,
+                    );
+                    None
+                }
+            }
+            Cfg::Named(ref cfg_name, ref cfg_value) => {
+                let define = config.defines.iter().find(|(key, ..)| {
+                    DefineKey::Named(cfg_name, cfg_value) == DefineKey::load(key)
+                });
+                if let Some((_, define)) = define {
+                    Some(Condition::Define(define.to_owned()))
+                } else {
+                    warn!(
+                        "Missing `[defines]` entry for `{}` in cbindgen config.",
+                        self,
+                    );
+                    None
+                }
+            }
+            Cfg::Any(ref children) => {
+                let conditions: Vec<_> = children
+                    .iter()
+                    .filter_map(|x| x.to_condition(config))
+                    .collect();
+                match conditions.len() {
+                    0 => None,
+                    1 => conditions.into_iter().next(),
+                    _ => Some(Condition::Any(conditions)),
+                }
+            }
+            Cfg::All(ref children) => {
+                let cfgs: Vec<_> = children
+                    .iter()
+                    .filter_map(|x| x.to_condition(config))
+                    .collect();
+                match cfgs.len() {
+                    0 => None,
+                    1 => cfgs.into_iter().next(),
+                    _ => Some(Condition::All(cfgs)),
+                }
+            }
+            Cfg::Not(ref child) => child
+                .to_condition(config)
+                .map(|cfg| Condition::Not(Box::new(cfg))),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Condition {
+    Define(String),
+    Any(Vec<Condition>),
+    All(Vec<Condition>),
+    Not(Box<Condition>),
+}
+
+impl Condition {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        match *self {
+            Condition::Define(ref define) => {
+                if config.language == Language::Cython {
+                    write!(out, "{}", define);
+                } else {
+                    out.write("defined(");
+                    write!(out, "{}", define);
+                    out.write(")");
+                }
+            }
+            Condition::Any(ref conditions) => {
+                out.write("(");
+                for (i, condition) in conditions.iter().enumerate() {
+                    if i != 0 {
+                        out.write(if config.language == Language::Cython {
+                            " or "
+                        } else {
+                            " || "
+                        });
+                    }
+                    condition.write(config, out);
+                }
+                out.write(")");
+            }
+            Condition::All(ref conditions) => {
+                out.write("(");
+                for (i, condition) in conditions.iter().enumerate() {
+                    if i != 0 {
+                        out.write(if config.language == Language::Cython {
+                            " and "
+                        } else {
+                            " && "
+                        });
+                    }
+                    condition.write(config, out);
+                }
+                out.write(")");
+            }
+            Condition::Not(ref condition) => {
+                out.write(if config.language == Language::Cython {
+                    "not "
+                } else {
+                    "!"
+                });
+                condition.write(config, out);
+            }
+        }
+    }
+}
+
+pub trait ConditionWrite {
+    fn write_before<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>);
+    fn write_after<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>);
+}
+
+impl ConditionWrite for Option<Condition> {
+    fn write_before<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        if let Some(ref cfg) = *self {
+            if config.language == Language::Cython {
+                out.write("IF ");
+                cfg.write(config, out);
+                out.open_brace();
+            } else {
+                out.push_set_spaces(0);
+                out.write("#if ");
+                cfg.write(config, out);
+                out.pop_set_spaces();
+                out.new_line();
+            }
+        }
+    }
+
+    fn write_after<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        if self.is_some() {
+            if config.language == Language::Cython {
+                out.close_brace(false);
+            } else {
+                out.new_line();
+                out.push_set_spaces(0);
+                out.write("#endif");
+                out.pop_set_spaces();
+            }
+        }
+    }
+}
diff --git a/src/bindgen/ir/constant.rs b/src/bindgen/ir/constant.rs
new file mode 100644
index 0000000..d3b9bd4
--- /dev/null
+++ b/src/bindgen/ir/constant.rs
@@ -0,0 +1,813 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::io::Write;
+
+use syn::ext::IdentExt;
+use syn::{self, UnOp};
+
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, ConditionWrite, Documentation, GenericParams, Item, ItemContainer, Path,
+    Struct, ToCondition, Type,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::writer::{Source, SourceWriter};
+use crate::bindgen::Bindings;
+
+fn member_to_ident(member: &syn::Member) -> String {
+    match member {
+        syn::Member::Named(ref name) => name.unraw().to_string(),
+        syn::Member::Unnamed(ref index) => format!("_{}", index.index),
+    }
+}
+
+// TODO: Maybe add support to more std associated constants.
+fn to_known_assoc_constant(associated_to: &Path, name: &str) -> Option<String> {
+    use crate::bindgen::ir::{IntKind, PrimitiveType};
+
+    if name != "MAX" && name != "MIN" {
+        return None;
+    }
+
+    let prim = PrimitiveType::maybe(associated_to.name())?;
+    let prefix = match prim {
+        PrimitiveType::Integer {
+            kind,
+            signed,
+            zeroable: _,
+        } => match kind {
+            IntKind::B8 => {
+                if signed {
+                    "INT8"
+                } else {
+                    "UINT8"
+                }
+            }
+            IntKind::B16 => {
+                if signed {
+                    "INT16"
+                } else {
+                    "UINT16"
+                }
+            }
+            IntKind::B32 => {
+                if signed {
+                    "INT32"
+                } else {
+                    "UINT32"
+                }
+            }
+            IntKind::B64 => {
+                if signed {
+                    "INT64"
+                } else {
+                    "UINT64"
+                }
+            }
+            _ => return None,
+        },
+        _ => return None,
+    };
+    Some(format!("{}_{}", prefix, name))
+}
+
+#[derive(Debug, Clone)]
+pub enum Literal {
+    Expr(String),
+    Path {
+        associated_to: Option<(Path, String)>,
+        name: String,
+    },
+    PostfixUnaryOp {
+        op: &'static str,
+        value: Box<Literal>,
+    },
+    BinOp {
+        left: Box<Literal>,
+        op: &'static str,
+        right: Box<Literal>,
+    },
+    FieldAccess {
+        base: Box<Literal>,
+        field: String,
+    },
+    Struct {
+        path: Path,
+        export_name: String,
+        fields: HashMap<String, Literal>,
+    },
+    Cast {
+        ty: Type,
+        value: Box<Literal>,
+    },
+}
+
+impl Literal {
+    fn replace_self_with(&mut self, self_ty: &Path) {
+        match *self {
+            Literal::PostfixUnaryOp { ref mut value, .. } => {
+                value.replace_self_with(self_ty);
+            }
+            Literal::BinOp {
+                ref mut left,
+                ref mut right,
+                ..
+            } => {
+                left.replace_self_with(self_ty);
+                right.replace_self_with(self_ty);
+            }
+            Literal::FieldAccess { ref mut base, .. } => {
+                base.replace_self_with(self_ty);
+            }
+            Literal::Struct {
+                ref mut path,
+                ref mut export_name,
+                ref mut fields,
+            } => {
+                if path.replace_self_with(self_ty) {
+                    *export_name = self_ty.name().to_owned();
+                }
+                for ref mut expr in fields.values_mut() {
+                    expr.replace_self_with(self_ty);
+                }
+            }
+            Literal::Cast {
+                ref mut ty,
+                ref mut value,
+            } => {
+                ty.replace_self_with(self_ty);
+                value.replace_self_with(self_ty);
+            }
+            Literal::Path {
+                ref mut associated_to,
+                ..
+            } => {
+                if let Some((ref mut path, ref mut export_name)) = *associated_to {
+                    if path.replace_self_with(self_ty) {
+                        *export_name = self_ty.name().to_owned();
+                    }
+                }
+            }
+            Literal::Expr(..) => {}
+        }
+    }
+
+    fn is_valid(&self, bindings: &Bindings) -> bool {
+        match *self {
+            Literal::Expr(..) => true,
+            Literal::Path {
+                ref associated_to,
+                ref name,
+            } => {
+                if let Some((ref path, _export_name)) = associated_to {
+                    return bindings.struct_exists(path)
+                        || to_known_assoc_constant(path, name).is_some();
+                }
+                true
+            }
+            Literal::PostfixUnaryOp { ref value, .. } => value.is_valid(bindings),
+            Literal::BinOp {
+                ref left,
+                ref right,
+                ..
+            } => left.is_valid(bindings) && right.is_valid(bindings),
+            Literal::FieldAccess { ref base, .. } => base.is_valid(bindings),
+            Literal::Struct { ref path, .. } => bindings.struct_exists(path),
+            Literal::Cast { ref value, .. } => value.is_valid(bindings),
+        }
+    }
+
+    fn can_be_constexpr(&self) -> bool {
+        !self.has_pointer_casts()
+    }
+
+    fn visit(&self, visitor: &mut impl FnMut(&Self) -> bool) -> bool {
+        if !visitor(self) {
+            return false;
+        }
+        match self {
+            Literal::Expr(..) | Literal::Path { .. } => true,
+            Literal::PostfixUnaryOp { ref value, .. } => value.visit(visitor),
+            Literal::BinOp {
+                ref left,
+                ref right,
+                ..
+            } => left.visit(visitor) && right.visit(visitor),
+            Literal::FieldAccess { ref base, .. } => base.visit(visitor),
+            Literal::Struct { ref fields, .. } => {
+                for (_name, field) in fields.iter() {
+                    if !field.visit(visitor) {
+                        return false;
+                    }
+                }
+                true
+            }
+            Literal::Cast { ref value, .. } => value.visit(visitor),
+        }
+    }
+
+    fn has_pointer_casts(&self) -> bool {
+        let mut has_pointer_casts = false;
+        self.visit(&mut |lit| {
+            if let Literal::Cast { ref ty, .. } = *lit {
+                has_pointer_casts = has_pointer_casts || ty.is_ptr();
+            }
+            !has_pointer_casts
+        });
+        has_pointer_casts
+    }
+
+    pub fn uses_only_primitive_types(&self) -> bool {
+        let mut uses_only_primitive_types = true;
+        self.visit(&mut |lit| {
+            // XXX This is a bit sketchy, but alas.
+            uses_only_primitive_types = uses_only_primitive_types
+                && match *lit {
+                    Literal::Struct { .. } => false,
+                    Literal::Cast { ref ty, .. } => ty.is_primitive_or_ptr_primitive(),
+                    _ => true,
+                };
+            uses_only_primitive_types
+        });
+        uses_only_primitive_types
+    }
+}
+
+impl Literal {
+    pub fn rename_for_config(&mut self, config: &Config) {
+        match self {
+            Literal::Struct {
+                ref mut export_name,
+                fields,
+                ..
+            } => {
+                config.export.rename(export_name);
+                for lit in fields.values_mut() {
+                    lit.rename_for_config(config);
+                }
+            }
+            Literal::FieldAccess { ref mut base, .. } => {
+                base.rename_for_config(config);
+            }
+            Literal::Path {
+                ref mut associated_to,
+                ref mut name,
+            } => {
+                if let Some((_path, ref mut export_name)) = associated_to {
+                    config.export.rename(export_name);
+                } else {
+                    config.export.rename(name);
+                }
+            }
+            Literal::PostfixUnaryOp { ref mut value, .. } => {
+                value.rename_for_config(config);
+            }
+            Literal::BinOp {
+                ref mut left,
+                ref mut right,
+                ..
+            } => {
+                left.rename_for_config(config);
+                right.rename_for_config(config);
+            }
+            Literal::Expr(_) => {}
+            Literal::Cast {
+                ref mut ty,
+                ref mut value,
+            } => {
+                ty.rename_for_config(config, &GenericParams::default());
+                value.rename_for_config(config);
+            }
+        }
+    }
+
+    // Translate from full blown `syn::Expr` into a simpler `Literal` type
+    pub fn load(expr: &syn::Expr) -> Result<Literal, String> {
+        match *expr {
+            // Match binary expressions of the form `a * b`
+            syn::Expr::Binary(ref bin_expr) => {
+                let l = Self::load(&bin_expr.left)?;
+                let r = Self::load(&bin_expr.right)?;
+                let op = match bin_expr.op {
+                    syn::BinOp::Add(..) => "+",
+                    syn::BinOp::Sub(..) => "-",
+                    syn::BinOp::Mul(..) => "*",
+                    syn::BinOp::Div(..) => "/",
+                    syn::BinOp::Rem(..) => "%",
+                    syn::BinOp::And(..) => "&&",
+                    syn::BinOp::Or(..) => "||",
+                    syn::BinOp::BitXor(..) => "^",
+                    syn::BinOp::BitAnd(..) => "&",
+                    syn::BinOp::BitOr(..) => "|",
+                    syn::BinOp::Shl(..) => "<<",
+                    syn::BinOp::Shr(..) => ">>",
+                    syn::BinOp::Eq(..) => "==",
+                    syn::BinOp::Lt(..) => "<",
+                    syn::BinOp::Le(..) => "<=",
+                    syn::BinOp::Ne(..) => "!=",
+                    syn::BinOp::Ge(..) => ">=",
+                    syn::BinOp::Gt(..) => ">",
+                    syn::BinOp::AddEq(..) => "+=",
+                    syn::BinOp::SubEq(..) => "-=",
+                    syn::BinOp::MulEq(..) => "*=",
+                    syn::BinOp::DivEq(..) => "/=",
+                    syn::BinOp::RemEq(..) => "%=",
+                    syn::BinOp::BitXorEq(..) => "^=",
+                    syn::BinOp::BitAndEq(..) => "&=",
+                    syn::BinOp::BitOrEq(..) => "|=",
+                    syn::BinOp::ShlEq(..) => "<<=",
+                    syn::BinOp::ShrEq(..) => ">>=",
+                };
+                Ok(Literal::BinOp {
+                    left: Box::new(l),
+                    op,
+                    right: Box::new(r),
+                })
+            }
+
+            // Match literals like true, 'a', 32 etc
+            syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => {
+                match lit {
+                    syn::Lit::Byte(ref value) => Ok(Literal::Expr(format!("{}", value.value()))),
+                    syn::Lit::Char(ref value) => Ok(Literal::Expr(match value.value() as u32 {
+                        0..=255 => format!("'{}'", value.value().escape_default()),
+                        other_code => format!(r"U'\U{:08X}'", other_code),
+                    })),
+                    syn::Lit::Int(ref value) => {
+                        let suffix = match value.suffix() {
+                            "u64" => "ull",
+                            "i64" => "ll",
+                            "u32" => "u",
+                            _ if value.base10_parse::<i64>().is_err() => "ull",
+                            _ => "",
+                        };
+                        Ok(Literal::Expr(format!(
+                            "{}{}",
+                            value.base10_digits(),
+                            suffix
+                        )))
+                    }
+                    syn::Lit::Float(ref value) => {
+                        Ok(Literal::Expr(value.base10_digits().to_string()))
+                    }
+                    syn::Lit::Bool(ref value) => Ok(Literal::Expr(format!("{}", value.value))),
+                    // TODO: Add support for byte string and Verbatim
+                    _ => Err(format!("Unsupported literal expression. {:?}", *lit)),
+                }
+            }
+
+            syn::Expr::Field(syn::ExprField {
+                ref base,
+                ref member,
+                ..
+            }) => Ok(Literal::FieldAccess {
+                base: Box::new(Literal::load(base)?),
+                field: member_to_ident(member),
+            }),
+
+            syn::Expr::Call(syn::ExprCall {
+                ref func, ref args, ..
+            }) => {
+                let struct_name = match Literal::load(func)? {
+                    Literal::Path {
+                        associated_to: None,
+                        name,
+                    } => name,
+                    _ => return Err(format!("Unsupported call expression. {:?}", *expr)),
+                };
+                let mut fields = HashMap::<String, Literal>::default();
+                for (index, arg) in args.iter().enumerate() {
+                    let ident =
+                        member_to_ident(&syn::Member::Unnamed(syn::Index::from(index))).to_string();
+                    let value = Literal::load(arg)?;
+                    fields.insert(ident, value);
+                }
+                Ok(Literal::Struct {
+                    path: Path::new(struct_name.clone()),
+                    export_name: struct_name,
+                    fields,
+                })
+            }
+
+            syn::Expr::Struct(syn::ExprStruct {
+                ref path,
+                ref fields,
+                ..
+            }) => {
+                let struct_name = path.segments[0].ident.unraw().to_string();
+                let mut field_map = HashMap::<String, Literal>::default();
+                for field in fields {
+                    let ident = member_to_ident(&field.member).to_string();
+                    let value = Literal::load(&field.expr)?;
+                    field_map.insert(ident, value);
+                }
+                Ok(Literal::Struct {
+                    path: Path::new(struct_name.clone()),
+                    export_name: struct_name,
+                    fields: field_map,
+                })
+            }
+
+            syn::Expr::Unary(syn::ExprUnary {
+                ref op, ref expr, ..
+            }) => match *op {
+                UnOp::Not(_) => {
+                    let val = Self::load(expr)?;
+                    Ok(Literal::PostfixUnaryOp {
+                        op: "~",
+                        value: Box::new(val),
+                    })
+                }
+                UnOp::Neg(_) => {
+                    let val = Self::load(expr)?;
+                    Ok(Literal::PostfixUnaryOp {
+                        op: "-",
+                        value: Box::new(val),
+                    })
+                }
+                _ => Err(format!("Unsupported Unary expression. {:?}", *op)),
+            },
+
+            // Match identifiers, like `5 << SHIFT`
+            syn::Expr::Path(syn::ExprPath { ref path, .. }) => {
+                // Handle only the simplest identifiers and Associated::IDENT
+                // kind of syntax.
+                Ok(match path.segments.len() {
+                    1 => Literal::Path {
+                        associated_to: None,
+                        name: path.segments[0].ident.to_string(),
+                    },
+                    2 => {
+                        let struct_name = path.segments[0].ident.to_string();
+                        Literal::Path {
+                            associated_to: Some((Path::new(&struct_name), struct_name)),
+                            name: path.segments[1].ident.to_string(),
+                        }
+                    }
+                    _ => return Err(format!("Unsupported path expression. {:?}", path)),
+                })
+            }
+
+            syn::Expr::Paren(syn::ExprParen { ref expr, .. }) => Self::load(expr),
+
+            syn::Expr::Cast(syn::ExprCast {
+                ref expr, ref ty, ..
+            }) => {
+                let val = Self::load(expr)?;
+                match Type::load(ty)? {
+                    Some(ty) => Ok(Literal::Cast {
+                        ty,
+                        value: Box::new(val),
+                    }),
+                    None => Err("Cannot cast to zero sized type.".to_owned()),
+                }
+            }
+
+            _ => Err(format!("Unsupported expression. {:?}", *expr)),
+        }
+    }
+
+    pub(crate) fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        match self {
+            Literal::Expr(v) => match (&**v, config.language) {
+                ("true", Language::Cython) => write!(out, "True"),
+                ("false", Language::Cython) => write!(out, "False"),
+                (v, _) => write!(out, "{}", v),
+            },
+            Literal::Path {
+                ref associated_to,
+                ref name,
+            } => {
+                if let Some((ref path, ref export_name)) = associated_to {
+                    if let Some(known) = to_known_assoc_constant(path, name) {
+                        return write!(out, "{}", known);
+                    }
+                    let path_separator = match config.language {
+                        Language::Cython | Language::C => "_",
+                        Language::Cxx => {
+                            if config.structure.associated_constants_in_body {
+                                "::"
+                            } else {
+                                "_"
+                            }
+                        }
+                    };
+                    write!(out, "{}{}", export_name, path_separator)
+                }
+                write!(out, "{}", name)
+            }
+            Literal::FieldAccess {
+                ref base,
+                ref field,
+            } => {
+                write!(out, "(");
+                base.write(config, out);
+                write!(out, ").{}", field);
+            }
+            Literal::PostfixUnaryOp { op, ref value } => {
+                write!(out, "{}", op);
+                value.write(config, out);
+            }
+            Literal::BinOp {
+                ref left,
+                op,
+                ref right,
+            } => {
+                write!(out, "(");
+                left.write(config, out);
+                write!(out, " {} ", op);
+                right.write(config, out);
+                write!(out, ")");
+            }
+            Literal::Cast { ref ty, ref value } => {
+                out.write(if config.language == Language::Cython {
+                    "<"
+                } else {
+                    "("
+                });
+                ty.write(config, out);
+                out.write(if config.language == Language::Cython {
+                    ">"
+                } else {
+                    ")"
+                });
+                value.write(config, out);
+            }
+            Literal::Struct {
+                export_name,
+                fields,
+                path,
+            } => {
+                match config.language {
+                    Language::C => write!(out, "({})", export_name),
+                    Language::Cxx => write!(out, "{}", export_name),
+                    Language::Cython => write!(out, "<{}>", export_name),
+                }
+
+                write!(out, "{{ ");
+                let mut is_first_field = true;
+                // In C++, same order as defined is required.
+                let ordered_fields = out.bindings().struct_field_names(path);
+                for ordered_key in ordered_fields.iter() {
+                    if let Some(lit) = fields.get(ordered_key) {
+                        if !is_first_field {
+                            write!(out, ", ");
+                        } else {
+                            is_first_field = false;
+                        }
+                        match config.language {
+                            Language::Cxx => write!(out, "/* .{} = */ ", ordered_key),
+                            Language::C => write!(out, ".{} = ", ordered_key),
+                            Language::Cython => {}
+                        }
+                        lit.write(config, out);
+                    }
+                }
+                write!(out, " }}");
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Constant {
+    pub path: Path,
+    pub export_name: String,
+    pub ty: Type,
+    pub value: Literal,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+    pub associated_to: Option<Path>,
+}
+
+impl Constant {
+    pub fn load(
+        path: Path,
+        mod_cfg: Option<&Cfg>,
+        ty: &syn::Type,
+        expr: &syn::Expr,
+        attrs: &[syn::Attribute],
+        associated_to: Option<Path>,
+    ) -> Result<Constant, String> {
+        let ty = Type::load(ty)?;
+        let mut ty = match ty {
+            Some(ty) => ty,
+            None => {
+                return Err("Cannot have a zero sized const definition.".to_owned());
+            }
+        };
+
+        let mut lit = Literal::load(expr)?;
+
+        if let Some(ref associated_to) = associated_to {
+            ty.replace_self_with(associated_to);
+            lit.replace_self_with(associated_to);
+        }
+
+        Ok(Constant::new(
+            path,
+            ty,
+            lit,
+            Cfg::append(mod_cfg, Cfg::load(attrs)),
+            AnnotationSet::load(attrs)?,
+            Documentation::load(attrs),
+            associated_to,
+        ))
+    }
+
+    pub fn new(
+        path: Path,
+        ty: Type,
+        value: Literal,
+        cfg: Option<Cfg>,
+        annotations: AnnotationSet,
+        documentation: Documentation,
+        associated_to: Option<Path>,
+    ) -> Self {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            ty,
+            value,
+            cfg,
+            annotations,
+            documentation,
+            associated_to,
+        }
+    }
+
+    pub fn uses_only_primitive_types(&self) -> bool {
+        self.value.uses_only_primitive_types() && self.ty.is_primitive_or_ptr_primitive()
+    }
+}
+
+impl Item for Constant {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        self.ty.add_dependencies(library, out);
+    }
+
+    fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    fn cfg(&self) -> Option<&Cfg> {
+        self.cfg.as_ref()
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::Constant(self.clone())
+    }
+
+    fn rename_for_config(&mut self, config: &Config) {
+        if self.associated_to.is_none() {
+            config.export.rename(&mut self.export_name);
+        }
+        self.value.rename_for_config(config);
+        self.ty.rename_for_config(config, &GenericParams::default()); // FIXME: should probably propagate something here
+    }
+
+    fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        self.ty.resolve_declaration_types(resolver);
+    }
+}
+
+impl Constant {
+    pub fn write_declaration<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        associated_to_struct: &Struct,
+    ) {
+        debug_assert!(self.associated_to.is_some());
+        debug_assert!(config.language == Language::Cxx);
+        debug_assert!(!associated_to_struct.is_transparent);
+        debug_assert!(config.structure.associated_constants_in_body);
+        debug_assert!(config.constant.allow_static_const);
+
+        if let Type::Ptr { is_const: true, .. } = self.ty {
+            out.write("static ");
+        } else {
+            out.write("static const ");
+        }
+        self.ty.write(config, out);
+        write!(out, " {};", self.export_name())
+    }
+
+    pub fn write<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        associated_to_struct: Option<&Struct>,
+    ) {
+        if let Some(assoc) = associated_to_struct {
+            if assoc.is_generic() {
+                return; // Not tested / implemented yet, so bail out.
+            }
+        }
+
+        if !self.value.is_valid(out.bindings()) {
+            return;
+        }
+
+        let associated_to_transparent = associated_to_struct.map_or(false, |s| s.is_transparent);
+
+        let in_body = associated_to_struct.is_some()
+            && config.language == Language::Cxx
+            && config.structure.associated_constants_in_body
+            && config.constant.allow_static_const
+            && !associated_to_transparent;
+
+        let condition = self.cfg.to_condition(config);
+        condition.write_before(config, out);
+
+        let name = if in_body {
+            Cow::Owned(format!(
+                "{}::{}",
+                associated_to_struct.unwrap().export_name(),
+                self.export_name(),
+            ))
+        } else if self.associated_to.is_none() {
+            Cow::Borrowed(self.export_name())
+        } else {
+            let associated_name = match associated_to_struct {
+                Some(s) => Cow::Borrowed(s.export_name()),
+                None => {
+                    let mut name = self.associated_to.as_ref().unwrap().name().to_owned();
+                    config.export.rename(&mut name);
+                    Cow::Owned(name)
+                }
+            };
+
+            Cow::Owned(format!("{}_{}", associated_name, self.export_name()))
+        };
+
+        let value = match self.value {
+            Literal::Struct {
+                ref fields,
+                ref path,
+                ..
+            } if out.bindings().struct_is_transparent(path) => fields.iter().next().unwrap().1,
+            _ => &self.value,
+        };
+
+        self.documentation.write(config, out);
+
+        let allow_constexpr = config.constant.allow_constexpr && self.value.can_be_constexpr();
+        match config.language {
+            Language::Cxx if config.constant.allow_static_const || allow_constexpr => {
+                if allow_constexpr {
+                    out.write("constexpr ")
+                }
+
+                if config.constant.allow_static_const {
+                    out.write(if in_body { "inline " } else { "static " });
+                }
+
+                if let Type::Ptr { is_const: true, .. } = self.ty {
+                    // Nothing.
+                } else {
+                    out.write("const ");
+                }
+
+                self.ty.write(config, out);
+                write!(out, " {} = ", name);
+                value.write(config, out);
+                write!(out, ";");
+            }
+            Language::Cxx | Language::C => {
+                write!(out, "#define {} ", name);
+                value.write(config, out);
+            }
+            Language::Cython => {
+                out.write("const ");
+                self.ty.write(config, out);
+                // For extern Cython declarations the initializer is ignored,
+                // but still useful as documentation, so we write it as a comment.
+                write!(out, " {} # = ", name);
+                value.write(config, out);
+            }
+        }
+
+        condition.write_after(config, out);
+    }
+}
diff --git a/src/bindgen/ir/documentation.rs b/src/bindgen/ir/documentation.rs
new file mode 100644
index 0000000..6822c0e
--- /dev/null
+++ b/src/bindgen/ir/documentation.rs
@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use crate::bindgen::config::{Config, DocumentationLength, DocumentationStyle, Language};
+use crate::bindgen::utilities::SynAttributeHelpers;
+use crate::bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct Documentation {
+    pub doc_comment: Vec<String>,
+}
+
+impl Documentation {
+    pub fn load(attrs: &[syn::Attribute]) -> Self {
+        let doc = attrs
+            .get_comment_lines()
+            .into_iter()
+            .filter(|x| !x.trim_start().starts_with("cbindgen:"))
+            .collect();
+
+        Documentation { doc_comment: doc }
+    }
+
+    pub fn simple(line: &str) -> Self {
+        Documentation {
+            doc_comment: vec![line.to_owned()],
+        }
+    }
+
+    pub fn none() -> Self {
+        Documentation {
+            doc_comment: Vec::new(),
+        }
+    }
+}
+
+impl Source for Documentation {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        if self.doc_comment.is_empty() || !config.documentation {
+            return;
+        }
+
+        let end = match config.documentation_length {
+            DocumentationLength::Short => 1,
+            DocumentationLength::Full => self.doc_comment.len(),
+        };
+
+        // Cython uses Python-style comments, so `documentation_style` is not relevant.
+        if config.language == Language::Cython {
+            for line in &self.doc_comment[..end] {
+                write!(out, "#{}", line);
+                out.new_line();
+            }
+            return;
+        }
+
+        let style = match config.documentation_style {
+            DocumentationStyle::Auto if config.language == Language::C => DocumentationStyle::Doxy,
+            DocumentationStyle::Auto if config.language == Language::Cxx => DocumentationStyle::Cxx,
+            DocumentationStyle::Auto => DocumentationStyle::C, // Fallback if `Language` gets extended.
+            other => other,
+        };
+
+        // Following these documents for style conventions:
+        // https://en.wikibooks.org/wiki/C++_Programming/Code/Style_Conventions/Comments
+        // https://www.cs.cmu.edu/~410/doc/doxygen.html
+        match style {
+            DocumentationStyle::C => {
+                out.write("/*");
+                out.new_line();
+            }
+
+            DocumentationStyle::Doxy => {
+                out.write("/**");
+                out.new_line();
+            }
+
+            _ => (),
+        }
+
+        for line in &self.doc_comment[..end] {
+            match style {
+                DocumentationStyle::C => out.write(""),
+                DocumentationStyle::Doxy => out.write(" *"),
+                DocumentationStyle::C99 => out.write("//"),
+                DocumentationStyle::Cxx => out.write("///"),
+                DocumentationStyle::Auto => unreachable!(), // Auto case should always be covered
+            }
+
+            write!(out, "{}", line);
+            out.new_line();
+        }
+
+        match style {
+            DocumentationStyle::C => {
+                out.write(" */");
+                out.new_line();
+            }
+
+            DocumentationStyle::Doxy => {
+                out.write(" */");
+                out.new_line();
+            }
+
+            _ => (),
+        }
+    }
+}
diff --git a/src/bindgen/ir/enumeration.rs b/src/bindgen/ir/enumeration.rs
new file mode 100644
index 0000000..a456b76
--- /dev/null
+++ b/src/bindgen/ir/enumeration.rs
@@ -0,0 +1,1556 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, AnnotationValue, Cfg, ConditionWrite, DeprecatedNoteKind, Documentation, Field,
+    GenericArgument, GenericParams, GenericPath, Item, ItemContainer, Literal, Path, Repr,
+    ReprStyle, Struct, ToCondition, Type,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::mangle;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::rename::{IdentifierType, RenameRule};
+use crate::bindgen::reserved;
+use crate::bindgen::writer::{ListType, Source, SourceWriter};
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, Clone)]
+pub enum VariantBody {
+    Empty(AnnotationSet),
+    Body {
+        /// The variant field / export name.
+        name: String,
+        /// The struct with all the items.
+        body: Struct,
+        /// A separate named struct is not created for this variant,
+        /// an unnamed struct is inlined at the point of use instead.
+        /// This is a reasonable thing to do only for tuple variants with a single field.
+        inline: bool,
+        /// Generated cast methods return the variant's only field instead of the variant itself.
+        /// For backward compatibility casts are inlined in a slightly
+        /// larger set of cases than whole variants.
+        inline_casts: bool,
+    },
+}
+
+impl VariantBody {
+    fn empty() -> Self {
+        Self::Empty(AnnotationSet::new())
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        match *self {
+            Self::Empty(ref anno) => anno,
+            Self::Body { ref body, .. } => &body.annotations,
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        match *self {
+            Self::Empty(..) => true,
+            Self::Body { .. } => false,
+        }
+    }
+
+    fn specialize(
+        &self,
+        generic_values: &[GenericArgument],
+        mappings: &[(&Path, &GenericArgument)],
+        config: &Config,
+    ) -> Self {
+        match *self {
+            Self::Empty(ref annos) => Self::Empty(annos.clone()),
+            Self::Body {
+                ref name,
+                ref body,
+                inline,
+                inline_casts,
+            } => Self::Body {
+                name: name.clone(),
+                body: body.specialize(generic_values, mappings, config),
+                inline,
+                inline_casts,
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct EnumVariant {
+    pub name: String,
+    pub export_name: String,
+    pub discriminant: Option<Literal>,
+    pub body: VariantBody,
+    pub cfg: Option<Cfg>,
+    pub documentation: Documentation,
+}
+
+impl EnumVariant {
+    fn load(
+        inline_tag_field: bool,
+        variant: &syn::Variant,
+        generic_params: GenericParams,
+        mod_cfg: Option<&Cfg>,
+        self_path: &Path,
+        enum_annotations: &AnnotationSet,
+        config: &Config,
+    ) -> Result<Self, String> {
+        let discriminant = match variant.discriminant {
+            Some((_, ref expr)) => Some(Literal::load(expr)?),
+            None => None,
+        };
+
+        fn parse_fields(
+            inline_tag_field: bool,
+            fields: &syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
+            self_path: &Path,
+            inline_name: Option<&str>,
+        ) -> Result<Vec<Field>, String> {
+            let mut res = Vec::new();
+
+            if inline_tag_field {
+                res.push(Field::from_name_and_type(
+                    inline_name.map_or_else(|| "tag".to_string(), |name| format!("{}_tag", name)),
+                    Type::Path(GenericPath::new(Path::new("Tag"), vec![])),
+                ));
+            }
+
+            for (i, field) in fields.iter().enumerate() {
+                if let Some(mut ty) = Type::load(&field.ty)? {
+                    ty.replace_self_with(self_path);
+                    res.push(Field {
+                        name: inline_name.map_or_else(
+                            || match field.ident {
+                                Some(ref ident) => ident.unraw().to_string(),
+                                None => i.to_string(),
+                            },
+                            |name| name.to_string(),
+                        ),
+                        ty,
+                        cfg: Cfg::load(&field.attrs),
+                        annotations: AnnotationSet::load(&field.attrs)?,
+                        documentation: Documentation::load(&field.attrs),
+                    });
+                }
+            }
+
+            Ok(res)
+        }
+
+        let variant_cfg = Cfg::append(mod_cfg, Cfg::load(&variant.attrs));
+        let mut annotations = AnnotationSet::load(&variant.attrs)?;
+        if let Some(b) = enum_annotations.bool("derive-ostream") {
+            annotations.add_default("derive-ostream", AnnotationValue::Bool(b));
+        }
+
+        let body_rule = enum_annotations
+            .parse_atom::<RenameRule>("rename-variant-name-fields")
+            .unwrap_or(config.enumeration.rename_variant_name_fields);
+
+        let body = match variant.fields {
+            syn::Fields::Unit => VariantBody::Empty(annotations),
+            syn::Fields::Named(ref fields) => {
+                let path = Path::new(format!("{}_Body", variant.ident));
+                let name = body_rule
+                    .apply(
+                        &variant.ident.unraw().to_string(),
+                        IdentifierType::StructMember,
+                    )
+                    .into_owned();
+                VariantBody::Body {
+                    body: Struct::new(
+                        path,
+                        generic_params,
+                        parse_fields(inline_tag_field, &fields.named, self_path, None)?,
+                        inline_tag_field,
+                        true,
+                        None,
+                        false,
+                        None,
+                        annotations,
+                        Documentation::none(),
+                    ),
+                    name,
+                    inline: false,
+                    inline_casts: false,
+                }
+            }
+            syn::Fields::Unnamed(ref fields) => {
+                let path = Path::new(format!("{}_Body", variant.ident));
+                let name = body_rule
+                    .apply(
+                        &variant.ident.unraw().to_string(),
+                        IdentifierType::StructMember,
+                    )
+                    .into_owned();
+                let inline_casts = fields.unnamed.len() == 1;
+                // In C++ types with destructors cannot be put into unnamed structs like the
+                // inlining requires, and it's hard to detect such types.
+                // Besides that for C++ we generate casts/getters that can be used instead of
+                // direct field accesses and also have a benefit of being checked.
+                // As a result we don't currently inline variant definitions in C++ mode at all.
+                let inline = inline_casts && config.language != Language::Cxx;
+                let inline_name = if inline { Some(&*name) } else { None };
+                VariantBody::Body {
+                    body: Struct::new(
+                        path,
+                        generic_params,
+                        parse_fields(inline_tag_field, &fields.unnamed, self_path, inline_name)?,
+                        inline_tag_field,
+                        true,
+                        None,
+                        false,
+                        None,
+                        annotations,
+                        Documentation::none(),
+                    ),
+                    name,
+                    inline,
+                    inline_casts,
+                }
+            }
+        };
+
+        Ok(EnumVariant::new(
+            variant.ident.unraw().to_string(),
+            discriminant,
+            body,
+            variant_cfg,
+            Documentation::load(&variant.attrs),
+        ))
+    }
+
+    pub fn new(
+        name: String,
+        discriminant: Option<Literal>,
+        body: VariantBody,
+        cfg: Option<Cfg>,
+        documentation: Documentation,
+    ) -> Self {
+        let export_name = name.clone();
+        Self {
+            name,
+            export_name,
+            discriminant,
+            body,
+            cfg,
+            documentation,
+        }
+    }
+
+    fn simplify_standard_types(&mut self, config: &Config) {
+        if let VariantBody::Body { ref mut body, .. } = self.body {
+            body.simplify_standard_types(config);
+        }
+    }
+
+    fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        if let VariantBody::Body { ref body, .. } = self.body {
+            body.add_dependencies(library, out);
+        }
+    }
+
+    fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        if let VariantBody::Body { ref mut body, .. } = self.body {
+            body.resolve_declaration_types(resolver);
+        }
+    }
+
+    fn specialize(
+        &self,
+        generic_values: &[GenericArgument],
+        mappings: &[(&Path, &GenericArgument)],
+        config: &Config,
+    ) -> Self {
+        Self::new(
+            mangle::mangle_name(&self.name, generic_values, &config.export.mangle),
+            self.discriminant.clone(),
+            self.body.specialize(generic_values, mappings, config),
+            self.cfg.clone(),
+            self.documentation.clone(),
+        )
+    }
+
+    fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+        if let VariantBody::Body { ref body, .. } = self.body {
+            body.add_monomorphs(library, out);
+        }
+    }
+
+    fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+        if let VariantBody::Body { ref mut body, .. } = self.body {
+            body.mangle_paths(monomorphs);
+        }
+    }
+}
+
+impl Source for EnumVariant {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        let condition = self.cfg.to_condition(config);
+        // Cython doesn't support conditional enum variants.
+        if config.language != Language::Cython {
+            condition.write_before(config, out);
+        }
+        self.documentation.write(config, out);
+        write!(out, "{}", self.export_name);
+        if let Some(discriminant) = &self.discriminant {
+            if config.language == Language::Cython {
+                // For extern Cython declarations the enumerator value is ignored,
+                // but still useful as documentation, so we write it as a comment.
+                out.write(" #")
+            }
+            out.write(" = ");
+            discriminant.write(config, out);
+        }
+        out.write(",");
+        if config.language != Language::Cython {
+            condition.write_after(config, out);
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Enum {
+    pub path: Path,
+    pub export_name: String,
+    pub generic_params: GenericParams,
+    pub repr: Repr,
+    pub variants: Vec<EnumVariant>,
+    pub tag: Option<String>,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+}
+
+impl Enum {
+    /// Name of the generated tag enum.
+    fn tag_name(&self) -> &str {
+        self.tag.as_deref().unwrap_or_else(|| self.export_name())
+    }
+
+    /// Enum with data turns into a union of structs with each struct having its own tag field.
+    fn inline_tag_field(repr: &Repr) -> bool {
+        repr.style != ReprStyle::C
+    }
+
+    pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+        if self.generic_params.len() > 0 {
+            return;
+        }
+
+        for v in &self.variants {
+            v.add_monomorphs(library, out);
+        }
+    }
+
+    fn can_derive_eq(&self) -> bool {
+        if self.tag.is_none() {
+            return false;
+        }
+
+        self.variants.iter().all(|variant| match variant.body {
+            VariantBody::Empty(..) => true,
+            VariantBody::Body { ref body, .. } => body.can_derive_eq(),
+        })
+    }
+
+    pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+        for variant in &mut self.variants {
+            variant.mangle_paths(monomorphs);
+        }
+    }
+
+    pub fn load(
+        item: &syn::ItemEnum,
+        mod_cfg: Option<&Cfg>,
+        config: &Config,
+    ) -> Result<Enum, String> {
+        let repr = Repr::load(&item.attrs)?;
+        if repr.style == ReprStyle::Rust && repr.ty.is_none() {
+            return Err("Enum is not marked with a valid #[repr(prim)] or #[repr(C)].".to_owned());
+        }
+        // TODO: Implement translation of aligned enums.
+        if repr.align.is_some() {
+            return Err("Enum is marked with #[repr(align(...))] or #[repr(packed)].".to_owned());
+        }
+
+        let path = Path::new(item.ident.unraw().to_string());
+        let generic_params = GenericParams::load(&item.generics)?;
+
+        let mut variants = Vec::new();
+        let mut has_data = false;
+
+        let annotations = AnnotationSet::load(&item.attrs)?;
+
+        for variant in item.variants.iter() {
+            let variant = EnumVariant::load(
+                Self::inline_tag_field(&repr),
+                variant,
+                generic_params.clone(),
+                mod_cfg,
+                &path,
+                &annotations,
+                config,
+            )?;
+            has_data = has_data || !variant.body.is_empty();
+            variants.push(variant);
+        }
+
+        if let Some(names) = annotations.list("enum-trailing-values") {
+            for name in names {
+                variants.push(EnumVariant::new(
+                    name,
+                    None,
+                    VariantBody::empty(),
+                    None,
+                    Documentation::none(),
+                ));
+            }
+        }
+
+        if config.enumeration.add_sentinel(&annotations) {
+            variants.push(EnumVariant::new(
+                "Sentinel".to_owned(),
+                None,
+                VariantBody::empty(),
+                None,
+                Documentation::simple(" Must be last for serialization purposes"),
+            ));
+        }
+
+        let tag = if has_data {
+            Some("Tag".to_string())
+        } else {
+            None
+        };
+
+        Ok(Enum::new(
+            path,
+            generic_params,
+            repr,
+            variants,
+            tag,
+            Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
+            annotations,
+            Documentation::load(&item.attrs),
+        ))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        path: Path,
+        generic_params: GenericParams,
+        repr: Repr,
+        variants: Vec<EnumVariant>,
+        tag: Option<String>,
+        cfg: Option<Cfg>,
+        annotations: AnnotationSet,
+        documentation: Documentation,
+    ) -> Self {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            generic_params,
+            repr,
+            variants,
+            tag,
+            cfg,
+            annotations,
+            documentation,
+        }
+    }
+}
+
+impl Item for Enum {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    fn cfg(&self) -> Option<&Cfg> {
+        self.cfg.as_ref()
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::Enum(self.clone())
+    }
+
+    fn collect_declaration_types(&self, resolver: &mut DeclarationTypeResolver) {
+        if self.tag.is_some() {
+            if self.repr.style == ReprStyle::C {
+                resolver.add_struct(&self.path);
+            } else {
+                resolver.add_union(&self.path);
+            }
+        } else if self.repr.style == ReprStyle::C {
+            resolver.add_enum(&self.path);
+        } else {
+            // This is important to handle conflicting names with opaque items.
+            resolver.add_none(&self.path);
+        }
+    }
+
+    fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        for &mut ref mut var in &mut self.variants {
+            var.resolve_declaration_types(resolver);
+        }
+    }
+
+    fn rename_for_config(&mut self, config: &Config) {
+        config.export.rename(&mut self.export_name);
+
+        if config.language != Language::Cxx && self.tag.is_some() {
+            // it makes sense to always prefix Tag with type name in C
+            let new_tag = format!("{}_Tag", self.export_name);
+            if self.repr.style == ReprStyle::Rust {
+                for variant in &mut self.variants {
+                    if let VariantBody::Body { ref mut body, .. } = variant.body {
+                        let path = Path::new(new_tag.clone());
+                        let generic_path = GenericPath::new(path, vec![]);
+                        body.fields[0].ty = Type::Path(generic_path);
+                    }
+                }
+            }
+            self.tag = Some(new_tag);
+        }
+
+        for variant in &mut self.variants {
+            reserved::escape(&mut variant.export_name);
+            if let Some(discriminant) = &mut variant.discriminant {
+                discriminant.rename_for_config(config);
+            }
+            if let VariantBody::Body {
+                ref mut name,
+                ref mut body,
+                ..
+            } = variant.body
+            {
+                body.rename_for_config(config);
+                reserved::escape(name);
+            }
+        }
+
+        if config.enumeration.prefix_with_name
+            || self.annotations.bool("prefix-with-name").unwrap_or(false)
+        {
+            let separator = if config.export.mangle.remove_underscores {
+                ""
+            } else {
+                "_"
+            };
+
+            for variant in &mut self.variants {
+                variant.export_name =
+                    format!("{}{}{}", self.export_name, separator, variant.export_name);
+                if let VariantBody::Body { ref mut body, .. } = variant.body {
+                    body.export_name =
+                        format!("{}{}{}", self.export_name, separator, body.export_name());
+                }
+            }
+        }
+
+        let rules = self
+            .annotations
+            .parse_atom::<RenameRule>("rename-all")
+            .unwrap_or(config.enumeration.rename_variants);
+
+        if let Some(r) = rules.not_none() {
+            self.variants = self
+                .variants
+                .iter()
+                .map(|variant| {
+                    EnumVariant::new(
+                        r.apply(
+                            &variant.export_name,
+                            IdentifierType::EnumVariant {
+                                prefix: &self.export_name,
+                            },
+                        )
+                        .into_owned(),
+                        variant.discriminant.clone(),
+                        match variant.body {
+                            VariantBody::Empty(..) => variant.body.clone(),
+                            VariantBody::Body {
+                                ref name,
+                                ref body,
+                                inline,
+                                inline_casts,
+                            } => VariantBody::Body {
+                                name: r.apply(name, IdentifierType::StructMember).into_owned(),
+                                body: body.clone(),
+                                inline,
+                                inline_casts,
+                            },
+                        },
+                        variant.cfg.clone(),
+                        variant.documentation.clone(),
+                    )
+                })
+                .collect();
+        }
+    }
+
+    fn instantiate_monomorph(
+        &self,
+        generic_values: &[GenericArgument],
+        library: &Library,
+        out: &mut Monomorphs,
+    ) {
+        let mappings = self.generic_params.call(self.path.name(), generic_values);
+
+        for variant in &self.variants {
+            if let VariantBody::Body { ref body, .. } = variant.body {
+                body.instantiate_monomorph(generic_values, library, out);
+            }
+        }
+
+        let mangled_path = mangle::mangle_path(
+            &self.path,
+            generic_values,
+            &library.get_config().export.mangle,
+        );
+
+        let monomorph = Enum::new(
+            mangled_path,
+            GenericParams::default(),
+            self.repr,
+            self.variants
+                .iter()
+                .map(|v| v.specialize(generic_values, &mappings, library.get_config()))
+                .collect(),
+            self.tag.clone(),
+            self.cfg.clone(),
+            self.annotations.clone(),
+            self.documentation.clone(),
+        );
+
+        out.insert_enum(library, self, monomorph, generic_values.to_owned());
+    }
+
+    fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        for variant in &self.variants {
+            variant.add_dependencies(library, out);
+        }
+    }
+}
+
+impl Source for Enum {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        let size = self.repr.ty.map(|ty| ty.to_primitive().to_repr_c(config));
+        let has_data = self.tag.is_some();
+        let inline_tag_field = Self::inline_tag_field(&self.repr);
+        let tag_name = self.tag_name();
+
+        let condition = self.cfg.to_condition(config);
+        condition.write_before(config, out);
+
+        self.documentation.write(config, out);
+        self.generic_params.write(config, out);
+
+        // If the enum has data, we need to emit a struct or union for the data
+        // and enum for the tag. C++ supports nested type definitions, so we open
+        // the struct or union here and define the tag enum inside it (*).
+        if has_data && config.language == Language::Cxx {
+            self.open_struct_or_union(config, out, inline_tag_field);
+        }
+
+        // Emit the tag enum and everything related to it.
+        self.write_tag_enum(config, out, size, has_data, tag_name);
+
+        // If the enum has data, we need to emit structs for the variants and gather them together.
+        if has_data {
+            self.write_variant_defs(config, out);
+            out.new_line();
+            out.new_line();
+
+            // Open the struct or union for the data (**), gathering all the variants with data
+            // together, unless it's C++, then we have already opened that struct/union at (*) and
+            // are currently inside it.
+            if config.language != Language::Cxx {
+                self.open_struct_or_union(config, out, inline_tag_field);
+            }
+
+            // Emit tag field that is separate from all variants.
+            self.write_tag_field(config, out, size, inline_tag_field, tag_name);
+            out.new_line();
+
+            // Open union of all variants with data, only in the non-inline tag scenario.
+            // Cython extern declarations don't manage layouts, layouts are defined entierly by the
+            // corresponding C code. So we can inline the unnamed union into the struct and get the
+            // same observable result. Moreother we have to do it because Cython doesn't support
+            // unnamed unions.
+            if !inline_tag_field && config.language != Language::Cython {
+                out.write("union");
+                out.open_brace();
+            }
+
+            // Emit fields for all variants with data.
+            self.write_variant_fields(config, out, inline_tag_field);
+
+            // Close union of all variants with data, only in the non-inline tag scenario.
+            // See the comment about Cython on `open_brace`.
+            if !inline_tag_field && config.language != Language::Cython {
+                out.close_brace(true);
+            }
+
+            // Emit convenience methods for the struct or enum for the data.
+            self.write_derived_functions_data(config, out, tag_name);
+
+            // Emit the post_body section, if relevant.
+            if let Some(body) = config.export.post_body(&self.path) {
+                out.new_line();
+                out.write_raw_block(body);
+            }
+
+            // Close the struct or union opened either at (*) or at (**).
+            if config.language == Language::C && config.style.generate_typedef() {
+                out.close_brace(false);
+                write!(out, " {};", self.export_name);
+            } else {
+                out.close_brace(true);
+            }
+        }
+
+        condition.write_after(config, out);
+    }
+}
+
+impl Enum {
+    /// Emit the tag enum and convenience methods for it.
+    /// For enums with data this is only a part of the output,
+    /// but for enums without data it's the whole output (modulo doc comments etc.).
+    fn write_tag_enum<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        size: Option<&str>,
+        has_data: bool,
+        tag_name: &str,
+    ) {
+        // Open the tag enum.
+        match config.language {
+            Language::C => {
+                if let Some(prim) = size {
+                    // If we need to specify size, then we have no choice but to create a typedef,
+                    // so `config.style` is not respected.
+                    write!(out, "enum");
+                    if let Some(note) = self
+                        .annotations
+                        .deprecated_note(config, DeprecatedNoteKind::Enum)
+                    {
+                        write!(out, " {}", note);
+                    }
+                    write!(out, " {}", tag_name);
+
+                    if config.cpp_compatible_c() {
+                        out.new_line();
+                        out.write("#ifdef __cplusplus");
+                        out.new_line();
+                        write!(out, "  : {}", prim);
+                        out.new_line();
+                        out.write("#endif // __cplusplus");
+                        out.new_line();
+                    }
+                } else {
+                    if config.style.generate_typedef() {
+                        out.write("typedef ");
+                    }
+                    out.write("enum");
+                    if let Some(note) = self
+                        .annotations
+                        .deprecated_note(config, DeprecatedNoteKind::Enum)
+                    {
+                        write!(out, " {}", note);
+                    }
+                    if config.style.generate_tag() {
+                        write!(out, " {}", tag_name);
+                    }
+                }
+            }
+            Language::Cxx => {
+                if config.enumeration.enum_class(&self.annotations) {
+                    out.write("enum class");
+                } else {
+                    out.write("enum");
+                }
+
+                if self.annotations.must_use(config) {
+                    if let Some(ref anno) = config.enumeration.must_use {
+                        write!(out, " {}", anno)
+                    }
+                }
+
+                if let Some(note) = self
+                    .annotations
+                    .deprecated_note(config, DeprecatedNoteKind::Enum)
+                {
+                    write!(out, " {}", note);
+                }
+
+                write!(out, " {}", tag_name);
+                if let Some(prim) = size {
+                    write!(out, " : {}", prim);
+                }
+            }
+            Language::Cython => {
+                if size.is_some() {
+                    // If we need to specify size, then we have no choice but to create a typedef,
+                    // so `config.style` is not respected.
+                    write!(out, "cdef enum");
+                } else {
+                    write!(out, "{}enum {}", config.style.cython_def(), tag_name);
+                }
+            }
+        }
+        out.open_brace();
+
+        // Emit enumerators for the tag enum.
+        for (i, variant) in self.variants.iter().enumerate() {
+            if i != 0 {
+                out.new_line()
+            }
+            variant.write(config, out);
+        }
+
+        // Close the tag enum.
+        if config.language == Language::C && size.is_none() && config.style.generate_typedef() {
+            out.close_brace(false);
+            write!(out, " {};", tag_name);
+        } else {
+            out.close_brace(true);
+        }
+
+        // Emit typedef specifying the tag enum's size if necessary.
+        // In C++ enums can "inherit" from numeric types (`enum E: uint8_t { ... }`),
+        // but in C `typedef uint8_t E` is the only way to give a fixed size to `E`.
+        if let Some(prim) = size {
+            if config.cpp_compatible_c() {
+                out.new_line_if_not_start();
+                out.write("#ifndef __cplusplus");
+            }
+
+            if config.language != Language::Cxx {
+                out.new_line();
+                write!(out, "{} {} {};", config.language.typedef(), prim, tag_name);
+            }
+
+            if config.cpp_compatible_c() {
+                out.new_line_if_not_start();
+                out.write("#endif // __cplusplus");
+            }
+        }
+
+        // Emit convenience methods for the tag enum.
+        self.write_derived_functions_enum(config, out, has_data, tag_name);
+    }
+
+    /// The code here mirrors the beginning of `Struct::write` and `Union::write`.
+    fn open_struct_or_union<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        inline_tag_field: bool,
+    ) {
+        match config.language {
+            Language::C if config.style.generate_typedef() => out.write("typedef "),
+            Language::C | Language::Cxx => {}
+            Language::Cython => out.write(config.style.cython_def()),
+        }
+
+        out.write(if inline_tag_field { "union" } else { "struct" });
+
+        if self.annotations.must_use(config) {
+            if let Some(ref anno) = config.structure.must_use {
+                write!(out, " {}", anno);
+            }
+        }
+
+        if let Some(note) = self
+            .annotations
+            .deprecated_note(config, DeprecatedNoteKind::Struct)
+        {
+            write!(out, " {} ", note);
+        }
+
+        if config.language != Language::C || config.style.generate_tag() {
+            write!(out, " {}", self.export_name());
+        }
+
+        out.open_brace();
+
+        // Emit the pre_body section, if relevant.
+        if let Some(body) = config.export.pre_body(&self.path) {
+            out.write_raw_block(body);
+            out.new_line();
+        }
+    }
+
+    /// Emit struct definitions for variants having data.
+    fn write_variant_defs<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        for variant in &self.variants {
+            if let VariantBody::Body {
+                ref body,
+                inline: false,
+                ..
+            } = variant.body
+            {
+                out.new_line();
+                out.new_line();
+                let condition = variant.cfg.to_condition(config);
+                // Cython doesn't support conditional enum variants.
+                if config.language != Language::Cython {
+                    condition.write_before(config, out);
+                }
+                body.write(config, out);
+                if config.language != Language::Cython {
+                    condition.write_after(config, out);
+                }
+            }
+        }
+    }
+
+    /// Emit tag field that is separate from all variants.
+    /// For non-inline tag scenario this is *the* tag field, and it does not exist in the variants.
+    /// For the inline tag scenario this is just a convenience and another way
+    /// to refer to the same tag that exist in all the variants.
+    fn write_tag_field<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        size: Option<&str>,
+        inline_tag_field: bool,
+        tag_name: &str,
+    ) {
+        // C++ allows accessing only common initial sequence of union
+        // fields so we have to wrap the tag field into an anonymous struct.
+        let wrap_tag = inline_tag_field && config.language == Language::Cxx;
+
+        if wrap_tag {
+            out.write("struct");
+            out.open_brace();
+        }
+
+        if config.language == Language::C && size.is_none() && !config.style.generate_typedef() {
+            out.write("enum ");
+        }
+
+        write!(out, "{} tag;", tag_name);
+
+        if wrap_tag {
+            out.close_brace(true);
+        }
+    }
+
+    /// Emit fields for all variants with data.
+    fn write_variant_fields<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        inline_tag_field: bool,
+    ) {
+        let mut first = true;
+        for variant in &self.variants {
+            if let VariantBody::Body {
+                name, body, inline, ..
+            } = &variant.body
+            {
+                if !first {
+                    out.new_line();
+                }
+                first = false;
+                let condition = variant.cfg.to_condition(config);
+                // Cython doesn't support conditional enum variants.
+                if config.language != Language::Cython {
+                    condition.write_before(config, out);
+                }
+                if *inline {
+                    // Write definition of an inlined variant with data.
+                    // Cython extern declarations don't manage layouts, layouts are defined entierly
+                    // by the corresponding C code. So we can inline the unnamed struct and get the
+                    // same observable result. Moreother we have to do it because Cython doesn't
+                    // support unnamed structs.
+                    // For the same reason with Cython we can omit per-variant tags (the first
+                    // field) to avoid extra noise, the main `tag` is enough in this case.
+                    if config.language != Language::Cython {
+                        out.write("struct");
+                        out.open_brace();
+                    }
+                    let start_field =
+                        usize::from(inline_tag_field && config.language == Language::Cython);
+                    out.write_vertical_source_list(&body.fields[start_field..], ListType::Cap(";"));
+                    if config.language != Language::Cython {
+                        out.close_brace(true);
+                    }
+                } else if config.style.generate_typedef() || config.language == Language::Cython {
+                    write!(out, "{} {};", body.export_name(), name);
+                } else {
+                    write!(out, "struct {} {};", body.export_name(), name);
+                }
+                if config.language != Language::Cython {
+                    condition.write_after(config, out);
+                }
+            }
+        }
+    }
+
+    // Emit convenience methods for enums themselves.
+    fn write_derived_functions_enum<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        has_data: bool,
+        tag_name: &str,
+    ) {
+        if config.language != Language::Cxx {
+            return;
+        }
+
+        // Emit an ostream function if required.
+        if config.enumeration.derive_ostream(&self.annotations) {
+            // For enums without data, this emits the serializer function for the
+            // enum. For enums with data, this emits the serializer function for
+            // the tag enum. In the latter case we need a couple of minor changes
+            // due to the function living inside the top-level struct or enum.
+            let stream = config
+                .function
+                .rename_args
+                .apply("stream", IdentifierType::FunctionArg);
+            let instance = config
+                .function
+                .rename_args
+                .apply("instance", IdentifierType::FunctionArg);
+
+            out.new_line();
+            out.new_line();
+            // For enums without data, we mark the function inline because the
+            // header might get included into multiple compilation units that
+            // get linked together, and not marking it inline would result in
+            // multiply-defined symbol errors. For enums with data we don't have
+            // the same problem, but mark it as a friend function of the
+            // containing union/struct.
+            // Note also that for enums with data, the case labels for switch
+            // statements apparently need to be qualified to the top-level
+            // generated struct or union. This is why the generated case labels
+            // below use the A::B::C format for enums with data, with A being
+            // self.export_name(). Failure to have that qualification results
+            // in a surprising compilation failure for the generated header.
+            write!(
+                out,
+                "{} std::ostream& operator<<(std::ostream& {}, const {}& {})",
+                if has_data { "friend" } else { "inline" },
+                stream,
+                tag_name,
+                instance,
+            );
+
+            out.open_brace();
+            if has_data {
+                // C++ name resolution rules are weird.
+                write!(
+                    out,
+                    "using {} = {}::{};",
+                    tag_name,
+                    self.export_name(),
+                    tag_name
+                );
+                out.new_line();
+            }
+            write!(out, "switch ({})", instance);
+            out.open_brace();
+            let vec: Vec<_> = self
+                .variants
+                .iter()
+                .map(|x| {
+                    format!(
+                        "case {}::{}: {} << \"{}\"; break;",
+                        tag_name, x.export_name, stream, x.export_name
+                    )
+                })
+                .collect();
+            out.write_vertical_source_list(&vec[..], ListType::Join(""));
+            out.close_brace(false);
+            out.new_line();
+
+            write!(out, "return {};", stream);
+            out.close_brace(false);
+
+            if has_data {
+                // For enums with data, this emits the serializer function for
+                // the top-level union or struct.
+                out.new_line();
+                out.new_line();
+                write!(
+                    out,
+                    "friend std::ostream& operator<<(std::ostream& {}, const {}& {})",
+                    stream,
+                    self.export_name(),
+                    instance,
+                );
+
+                out.open_brace();
+
+                // C++ name resolution rules are weird.
+                write!(
+                    out,
+                    "using {} = {}::{};",
+                    tag_name,
+                    self.export_name(),
+                    tag_name
+                );
+                out.new_line();
+
+                write!(out, "switch ({}.tag)", instance);
+                out.open_brace();
+                let vec: Vec<_> = self
+                    .variants
+                    .iter()
+                    .map(|x| {
+                        let tag_str = format!("\"{}\"", x.export_name);
+                        if let VariantBody::Body {
+                            ref name, ref body, ..
+                        } = x.body
+                        {
+                            format!(
+                                "case {}::{}: {} << {}{}{}.{}; break;",
+                                tag_name,
+                                x.export_name,
+                                stream,
+                                if body.has_tag_field { "" } else { &tag_str },
+                                if body.has_tag_field { "" } else { " << " },
+                                instance,
+                                name,
+                            )
+                        } else {
+                            format!(
+                                "case {}::{}: {} << {}; break;",
+                                tag_name, x.export_name, stream, tag_str,
+                            )
+                        }
+                    })
+                    .collect();
+                out.write_vertical_source_list(&vec[..], ListType::Join(""));
+                out.close_brace(false);
+                out.new_line();
+
+                write!(out, "return {};", stream);
+                out.close_brace(false);
+            }
+        }
+    }
+
+    // Emit convenience methods for structs or unions produced for enums with data.
+    fn write_derived_functions_data<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        tag_name: &str,
+    ) {
+        if config.language != Language::Cxx {
+            return;
+        }
+
+        if config.enumeration.derive_helper_methods(&self.annotations) {
+            for variant in &self.variants {
+                out.new_line();
+                out.new_line();
+
+                let condition = variant.cfg.to_condition(config);
+                condition.write_before(config, out);
+
+                let arg_renamer = |name: &str| {
+                    config
+                        .function
+                        .rename_args
+                        .apply(name, IdentifierType::FunctionArg)
+                        .into_owned()
+                };
+
+                macro_rules! write_attrs {
+                    ($op:expr) => {{
+                        if let Some(Some(attrs)) =
+                            variant
+                                .body
+                                .annotations()
+                                .atom(concat!("variant-", $op, "-attributes"))
+                        {
+                            write!(out, "{} ", attrs);
+                        }
+                    }};
+                }
+
+                write_attrs!("constructor");
+                write!(out, "static {} {}(", self.export_name, variant.export_name);
+
+                if let VariantBody::Body { ref body, .. } = variant.body {
+                    let skip_fields = body.has_tag_field as usize;
+                    let vec: Vec<_> = body
+                        .fields
+                        .iter()
+                        .skip(skip_fields)
+                        .map(|field| {
+                            Field::from_name_and_type(
+                                // const-ref args to constructor
+                                arg_renamer(&field.name),
+                                Type::const_ref_to(&field.ty),
+                            )
+                        })
+                        .collect();
+                    out.write_vertical_source_list(&vec[..], ListType::Join(","));
+                }
+
+                write!(out, ")");
+                out.open_brace();
+
+                write!(out, "{} result;", self.export_name);
+
+                if let VariantBody::Body {
+                    name: ref variant_name,
+                    ref body,
+                    ..
+                } = variant.body
+                {
+                    let skip_fields = body.has_tag_field as usize;
+                    for field in body.fields.iter().skip(skip_fields) {
+                        out.new_line();
+                        match field.ty {
+                            Type::Array(ref ty, ref length) => {
+                                // arrays are not assignable in C++ so we
+                                // need to manually copy the elements
+                                write!(out, "for (int i = 0; i < {}; i++)", length.as_str());
+                                out.open_brace();
+                                write!(out, "::new (&result.{}.{}[i]) (", variant_name, field.name);
+                                ty.write(config, out);
+                                write!(out, ")({}[i]);", arg_renamer(&field.name));
+                                out.close_brace(false);
+                            }
+                            ref ty => {
+                                write!(out, "::new (&result.{}.{}) (", variant_name, field.name);
+                                ty.write(config, out);
+                                write!(out, ")({});", arg_renamer(&field.name));
+                            }
+                        }
+                    }
+                }
+
+                out.new_line();
+                write!(out, "result.tag = {}::{};", tag_name, variant.export_name);
+                out.new_line();
+                write!(out, "return result;");
+                out.close_brace(false);
+
+                out.new_line();
+                out.new_line();
+
+                write_attrs!("is");
+                // FIXME: create a config for method case
+                write!(out, "bool Is{}() const", variant.export_name);
+                out.open_brace();
+                write!(out, "return tag == {}::{};", tag_name, variant.export_name);
+                out.close_brace(false);
+
+                let assert_name = match config.enumeration.cast_assert_name {
+                    Some(ref n) => &**n,
+                    None => "assert",
+                };
+
+                let mut derive_casts = |const_casts: bool| {
+                    let (member_name, body, inline_casts) = match variant.body {
+                        VariantBody::Body {
+                            ref name,
+                            ref body,
+                            inline_casts,
+                            ..
+                        } => (name, body, inline_casts),
+                        VariantBody::Empty(..) => return,
+                    };
+
+                    let skip_fields = body.has_tag_field as usize;
+                    let field_count = body.fields.len() - skip_fields;
+                    if field_count == 0 {
+                        return;
+                    }
+
+                    out.new_line();
+                    out.new_line();
+
+                    if const_casts {
+                        write_attrs!("const-cast");
+                    } else {
+                        write_attrs!("mut-cast");
+                    }
+                    if inline_casts {
+                        let field = body.fields.last().unwrap();
+                        let return_type = field.ty.clone();
+                        let return_type = Type::Ptr {
+                            ty: Box::new(return_type),
+                            is_const: const_casts,
+                            is_ref: true,
+                            is_nullable: false,
+                        };
+                        return_type.write(config, out);
+                    } else if const_casts {
+                        write!(out, "const {}&", body.export_name());
+                    } else {
+                        write!(out, "{}&", body.export_name());
+                    }
+
+                    write!(out, " As{}()", variant.export_name);
+                    if const_casts {
+                        write!(out, " const");
+                    }
+                    out.open_brace();
+                    write!(out, "{}(Is{}());", assert_name, variant.export_name);
+                    out.new_line();
+                    write!(out, "return {}", member_name);
+                    if inline_casts {
+                        write!(out, "._0");
+                    }
+                    write!(out, ";");
+                    out.close_brace(false);
+                };
+
+                if config.enumeration.derive_const_casts(&self.annotations) {
+                    derive_casts(true)
+                }
+
+                if config.enumeration.derive_mut_casts(&self.annotations) {
+                    derive_casts(false)
+                }
+
+                condition.write_after(config, out);
+            }
+        }
+
+        let other = config
+            .function
+            .rename_args
+            .apply("other", IdentifierType::FunctionArg);
+
+        macro_rules! write_attrs {
+            ($op:expr) => {{
+                if let Some(Some(attrs)) = self.annotations.atom(concat!($op, "-attributes")) {
+                    write!(out, "{} ", attrs);
+                }
+            }};
+        }
+
+        if self.can_derive_eq() && config.structure.derive_eq(&self.annotations) {
+            out.new_line();
+            out.new_line();
+            write_attrs!("eq");
+            write!(
+                out,
+                "bool operator==(const {}& {}) const",
+                self.export_name, other
+            );
+            out.open_brace();
+            write!(out, "if (tag != {}.tag)", other);
+            out.open_brace();
+            write!(out, "return false;");
+            out.close_brace(false);
+            out.new_line();
+            write!(out, "switch (tag)");
+            out.open_brace();
+            let mut exhaustive = true;
+            for variant in &self.variants {
+                if let VariantBody::Body {
+                    name: ref variant_name,
+                    ..
+                } = variant.body
+                {
+                    let condition = variant.cfg.to_condition(config);
+                    condition.write_before(config, out);
+                    write!(
+                        out,
+                        "case {}::{}: return {} == {}.{};",
+                        self.tag.as_ref().unwrap(),
+                        variant.export_name,
+                        variant_name,
+                        other,
+                        variant_name
+                    );
+                    condition.write_after(config, out);
+                    out.new_line();
+                } else {
+                    exhaustive = false;
+                }
+            }
+            if !exhaustive {
+                write!(out, "default: break;");
+            }
+            out.close_brace(false);
+
+            out.new_line();
+            write!(out, "return true;");
+
+            out.close_brace(false);
+
+            if config.structure.derive_neq(&self.annotations) {
+                out.new_line();
+                out.new_line();
+                write_attrs!("neq");
+                write!(
+                    out,
+                    "bool operator!=(const {}& {}) const",
+                    self.export_name, other
+                );
+                out.open_brace();
+                write!(out, "return !(*this == {});", other);
+                out.close_brace(false);
+            }
+        }
+
+        if config
+            .enumeration
+            .private_default_tagged_enum_constructor(&self.annotations)
+        {
+            out.new_line();
+            out.new_line();
+            write!(out, "private:");
+            out.new_line();
+            write!(out, "{}()", self.export_name);
+            out.open_brace();
+            out.close_brace(false);
+            out.new_line();
+            write!(out, "public:");
+            out.new_line();
+        }
+
+        if config
+            .enumeration
+            .derive_tagged_enum_destructor(&self.annotations)
+        {
+            out.new_line();
+            out.new_line();
+            write_attrs!("destructor");
+            write!(out, "~{}()", self.export_name);
+            out.open_brace();
+            write!(out, "switch (tag)");
+            out.open_brace();
+            let mut exhaustive = true;
+            for variant in &self.variants {
+                if let VariantBody::Body {
+                    ref name, ref body, ..
+                } = variant.body
+                {
+                    let condition = variant.cfg.to_condition(config);
+                    condition.write_before(config, out);
+                    write!(
+                        out,
+                        "case {}::{}: {}.~{}(); break;",
+                        self.tag.as_ref().unwrap(),
+                        variant.export_name,
+                        name,
+                        body.export_name(),
+                    );
+                    condition.write_after(config, out);
+                    out.new_line();
+                } else {
+                    exhaustive = false;
+                }
+            }
+            if !exhaustive {
+                write!(out, "default: break;");
+            }
+            out.close_brace(false);
+            out.close_brace(false);
+        }
+
+        if config
+            .enumeration
+            .derive_tagged_enum_copy_constructor(&self.annotations)
+        {
+            out.new_line();
+            out.new_line();
+            write_attrs!("copy-constructor");
+            write!(
+                out,
+                "{}(const {}& {})",
+                self.export_name, self.export_name, other
+            );
+            out.new_line();
+            write!(out, " : tag({}.tag)", other);
+            out.open_brace();
+            write!(out, "switch (tag)");
+            out.open_brace();
+            let mut exhaustive = true;
+            for variant in &self.variants {
+                if let VariantBody::Body {
+                    ref name, ref body, ..
+                } = variant.body
+                {
+                    let condition = variant.cfg.to_condition(config);
+                    condition.write_before(config, out);
+                    write!(
+                        out,
+                        "case {}::{}: ::new (&{}) ({})({}.{}); break;",
+                        self.tag.as_ref().unwrap(),
+                        variant.export_name,
+                        name,
+                        body.export_name(),
+                        other,
+                        name,
+                    );
+                    condition.write_after(config, out);
+                    out.new_line();
+                } else {
+                    exhaustive = false;
+                }
+            }
+            if !exhaustive {
+                write!(out, "default: break;");
+            }
+            out.close_brace(false);
+            out.close_brace(false);
+
+            if config
+                .enumeration
+                .derive_tagged_enum_copy_assignment(&self.annotations)
+            {
+                out.new_line();
+                write_attrs!("copy-assignment");
+                write!(
+                    out,
+                    "{}& operator=(const {}& {})",
+                    self.export_name, self.export_name, other
+                );
+                out.open_brace();
+                write!(out, "if (this != &{})", other);
+                out.open_brace();
+                write!(out, "this->~{}();", self.export_name);
+                out.new_line();
+                write!(out, "new (this) {}({});", self.export_name, other);
+                out.close_brace(false);
+                out.new_line();
+                write!(out, "return *this;");
+                out.close_brace(false);
+            }
+        }
+    }
+
+    pub fn simplify_standard_types(&mut self, config: &Config) {
+        for variant in &mut self.variants {
+            variant.simplify_standard_types(config);
+        }
+    }
+}
diff --git a/src/bindgen/ir/field.rs b/src/bindgen/ir/field.rs
new file mode 100644
index 0000000..6e132bf
--- /dev/null
+++ b/src/bindgen/ir/field.rs
@@ -0,0 +1,80 @@
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::cdecl;
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::ir::{AnnotationSet, Cfg, ConditionWrite};
+use crate::bindgen::ir::{Documentation, Path, ToCondition, Type};
+use crate::bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct Field {
+    pub name: String,
+    pub ty: Type,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+}
+
+impl Field {
+    pub fn from_name_and_type(name: String, ty: Type) -> Field {
+        Field {
+            name,
+            ty,
+            cfg: None,
+            annotations: AnnotationSet::new(),
+            documentation: Documentation::none(),
+        }
+    }
+
+    pub fn load(field: &syn::Field, self_path: &Path) -> Result<Option<Field>, String> {
+        Ok(if let Some(mut ty) = Type::load(&field.ty)? {
+            ty.replace_self_with(self_path);
+            Some(Field {
+                name: field
+                    .ident
+                    .as_ref()
+                    .ok_or_else(|| "field is missing identifier".to_string())?
+                    .unraw()
+                    .to_string(),
+                ty,
+                cfg: Cfg::load(&field.attrs),
+                annotations: AnnotationSet::load(&field.attrs)?,
+                documentation: Documentation::load(&field.attrs),
+            })
+        } else {
+            None
+        })
+    }
+}
+
+impl Source for Field {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        // Cython doesn't support conditional fields.
+        let condition = self.cfg.to_condition(config);
+        if config.language != Language::Cython {
+            condition.write_before(config, out);
+        }
+
+        self.documentation.write(config, out);
+        cdecl::write_field(out, &self.ty, &self.name, config);
+        // Cython extern declarations don't manage layouts, layouts are defined entierly by the
+        // corresponding C code. So we can omit bitfield sizes which are not supported by Cython.
+        if config.language != Language::Cython {
+            if let Some(bitfield) = self.annotations.atom("bitfield") {
+                write!(out, ": {}", bitfield.unwrap_or_default());
+            }
+        }
+
+        if config.language != Language::Cython {
+            condition.write_after(config, out);
+            // FIXME(#634): `write_vertical_source_list` should support
+            // configuring list elements natively. For now we print a newline
+            // here to avoid printing `#endif;` with semicolon.
+            if condition.is_some() {
+                out.new_line();
+            }
+        }
+    }
+}
diff --git a/src/bindgen/ir/function.rs b/src/bindgen/ir/function.rs
new file mode 100644
index 0000000..8c65f2f
--- /dev/null
+++ b/src/bindgen/ir/function.rs
@@ -0,0 +1,390 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::HashMap;
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::cdecl;
+use crate::bindgen::config::{Config, Language, Layout};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, ConditionWrite, DeprecatedNoteKind, Documentation, GenericPath, Path,
+    ToCondition, Type,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::rename::{IdentifierType, RenameRule};
+use crate::bindgen::reserved;
+use crate::bindgen::utilities::IterHelpers;
+use crate::bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct FunctionArgument {
+    pub name: Option<String>,
+    pub ty: Type,
+    pub array_length: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Function {
+    pub path: Path,
+    /// Path to the self-type of the function
+    /// If the function is a method, this will contain the path of the type in the impl block
+    pub self_type_path: Option<Path>,
+    pub ret: Type,
+    pub args: Vec<FunctionArgument>,
+    pub extern_decl: bool,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+    pub never_return: bool,
+}
+
+impl Function {
+    pub fn load(
+        path: Path,
+        self_type_path: Option<&Path>,
+        sig: &syn::Signature,
+        extern_decl: bool,
+        attrs: &[syn::Attribute],
+        mod_cfg: Option<&Cfg>,
+    ) -> Result<Function, String> {
+        let mut args = sig.inputs.iter().try_skip_map(|x| x.as_argument())?;
+
+        let (mut ret, never_return) = Type::load_from_output(&sig.output)?;
+
+        if let Some(self_path) = self_type_path {
+            for arg in &mut args {
+                arg.ty.replace_self_with(self_path);
+            }
+            ret.replace_self_with(self_path);
+        }
+
+        Ok(Function {
+            path,
+            self_type_path: self_type_path.cloned(),
+            ret,
+            args,
+            extern_decl,
+            cfg: Cfg::append(mod_cfg, Cfg::load(attrs)),
+            annotations: AnnotationSet::load(attrs)?,
+            documentation: Documentation::load(attrs),
+            never_return,
+        })
+    }
+
+    pub fn swift_name(&self, config: &Config) -> Option<String> {
+        if config.language == Language::Cython {
+            return None;
+        }
+        // If the symbol name starts with the type name, separate the two components with '.'
+        // so that Swift recognises the association between the method and the type
+        let (ref type_prefix, ref type_name) = match self.self_type_path {
+            Some(ref type_name) => {
+                let type_name = type_name.to_string();
+                if !self.path.name().starts_with(&type_name) {
+                    return Some(self.path.to_string());
+                }
+                (format!("{}.", type_name), type_name)
+            }
+            None => ("".to_string(), "".to_string()),
+        };
+
+        let item_name = self
+            .path
+            .name()
+            .trim_start_matches(type_name)
+            .trim_start_matches('_');
+
+        let item_args = {
+            let mut items = Vec::with_capacity(self.args.len());
+            for arg in self.args.iter() {
+                items.push(format!("{}:", arg.name.as_ref()?.as_str()));
+            }
+            items.join("")
+        };
+        Some(format!("{}{}({})", type_prefix, item_name, item_args))
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+
+    pub fn simplify_standard_types(&mut self, config: &Config) {
+        self.ret.simplify_standard_types(config);
+        for arg in &mut self.args {
+            arg.ty.simplify_standard_types(config);
+        }
+    }
+
+    pub fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        self.ret.add_dependencies(library, out);
+        for arg in &self.args {
+            arg.ty.add_dependencies(library, out);
+        }
+    }
+
+    pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+        self.ret.add_monomorphs(library, out);
+        for arg in &self.args {
+            arg.ty.add_monomorphs(library, out);
+        }
+    }
+
+    pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+        self.ret.mangle_paths(monomorphs);
+        for arg in &mut self.args {
+            arg.ty.mangle_paths(monomorphs);
+        }
+    }
+
+    pub fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        self.ret.resolve_declaration_types(resolver);
+        for arg in &mut self.args {
+            arg.ty.resolve_declaration_types(resolver);
+        }
+    }
+
+    pub fn rename_for_config(&mut self, config: &Config) {
+        // Rename the types used in arguments
+        let generic_params = Default::default();
+        self.ret.rename_for_config(config, &generic_params);
+
+        // Apply rename rules to argument names
+        let rules = self
+            .annotations
+            .parse_atom::<RenameRule>("rename-all")
+            .unwrap_or(config.function.rename_args);
+
+        if let Some(r) = rules.not_none() {
+            let args = std::mem::take(&mut self.args);
+            self.args = args
+                .into_iter()
+                .map(|arg| {
+                    let name = arg
+                        .name
+                        .map(|n| r.apply(&n, IdentifierType::FunctionArg).into_owned());
+                    FunctionArgument {
+                        name,
+                        ty: arg.ty,
+                        array_length: None,
+                    }
+                })
+                .collect()
+        }
+
+        // Escape C/C++ reserved keywords used in argument names, and
+        // recursively rename argument types.
+        for arg in &mut self.args {
+            arg.ty.rename_for_config(config, &generic_params);
+            if let Some(ref mut name) = arg.name {
+                reserved::escape(name);
+            }
+        }
+
+        // Save the array length of the pointer arguments which need to use
+        // the C-array notation
+        if let Some(tuples) = self.annotations.list("ptrs-as-arrays") {
+            let mut ptrs_as_arrays: HashMap<String, String> = HashMap::new();
+            for str_tuple in tuples {
+                let parts: Vec<&str> = str_tuple[1..str_tuple.len() - 1]
+                    .split(';')
+                    .map(|x| x.trim())
+                    .collect();
+                if parts.len() != 2 {
+                    warn!(
+                        "{:?} does not follow the correct syntax, so the annotation is being ignored",
+                        parts
+                    );
+                    continue;
+                }
+                ptrs_as_arrays.insert(parts[0].to_string(), parts[1].to_string());
+            }
+
+            for arg in &mut self.args {
+                match arg.ty {
+                    Type::Ptr { .. } => {}
+                    _ => continue,
+                }
+                let name = match arg.name {
+                    Some(ref name) => name,
+                    None => continue,
+                };
+                arg.array_length = ptrs_as_arrays.get(name).cloned();
+            }
+        }
+    }
+}
+
+impl Source for Function {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        fn write_1<W: Write>(func: &Function, config: &Config, out: &mut SourceWriter<W>) {
+            let prefix = config.function.prefix(&func.annotations);
+            let postfix = config.function.postfix(&func.annotations);
+
+            let condition = func.cfg.to_condition(config);
+            condition.write_before(config, out);
+
+            func.documentation.write(config, out);
+
+            if func.extern_decl {
+                out.write("extern ");
+            } else {
+                if let Some(ref prefix) = prefix {
+                    write!(out, "{} ", prefix);
+                }
+                if func.annotations.must_use(config) {
+                    if let Some(ref anno) = config.function.must_use {
+                        write!(out, "{} ", anno);
+                    }
+                }
+                if let Some(note) = func
+                    .annotations
+                    .deprecated_note(config, DeprecatedNoteKind::Function)
+                {
+                    write!(out, "{} ", note);
+                }
+            }
+            cdecl::write_func(out, func, Layout::Horizontal, config);
+
+            if !func.extern_decl {
+                if let Some(ref postfix) = postfix {
+                    write!(out, " {}", postfix);
+                }
+            }
+
+            if let Some(ref swift_name_macro) = config.function.swift_name_macro {
+                if let Some(swift_name) = func.swift_name(config) {
+                    write!(out, " {}({})", swift_name_macro, swift_name);
+                }
+            }
+
+            out.write(";");
+
+            condition.write_after(config, out);
+        }
+
+        fn write_2<W: Write>(func: &Function, config: &Config, out: &mut SourceWriter<W>) {
+            let prefix = config.function.prefix(&func.annotations);
+            let postfix = config.function.postfix(&func.annotations);
+
+            let condition = func.cfg.to_condition(config);
+
+            condition.write_before(config, out);
+
+            func.documentation.write(config, out);
+
+            if func.extern_decl {
+                out.write("extern ");
+            } else {
+                if let Some(ref prefix) = prefix {
+                    write!(out, "{}", prefix);
+                    out.new_line();
+                }
+                if func.annotations.must_use(config) {
+                    if let Some(ref anno) = config.function.must_use {
+                        write!(out, "{}", anno);
+                        out.new_line();
+                    }
+                }
+                if let Some(note) = func
+                    .annotations
+                    .deprecated_note(config, DeprecatedNoteKind::Function)
+                {
+                    write!(out, "{}", note);
+                    out.new_line();
+                }
+            }
+            cdecl::write_func(out, func, Layout::Vertical, config);
+            if !func.extern_decl {
+                if let Some(ref postfix) = postfix {
+                    out.new_line();
+                    write!(out, "{}", postfix);
+                }
+            }
+
+            if let Some(ref swift_name_macro) = config.function.swift_name_macro {
+                if let Some(swift_name) = func.swift_name(config) {
+                    write!(out, " {}({})", swift_name_macro, swift_name);
+                }
+            }
+
+            out.write(";");
+
+            condition.write_after(config, out);
+        }
+
+        match config.function.args {
+            Layout::Horizontal => write_1(self, config, out),
+            Layout::Vertical => write_2(self, config, out),
+            Layout::Auto => {
+                if !out.try_write(|out| write_1(self, config, out), config.line_length) {
+                    write_2(self, config, out)
+                }
+            }
+        }
+    }
+}
+
+trait SynFnArgHelpers {
+    fn as_argument(&self) -> Result<Option<FunctionArgument>, String>;
+}
+
+fn gen_self_type(receiver: &syn::Receiver) -> Type {
+    let self_ty = Type::Path(GenericPath::self_path());
+    if receiver.reference.is_none() {
+        return self_ty;
+    }
+
+    let is_const = receiver.mutability.is_none();
+    Type::Ptr {
+        ty: Box::new(self_ty),
+        is_const,
+        is_nullable: false,
+        is_ref: false,
+    }
+}
+
+impl SynFnArgHelpers for syn::FnArg {
+    fn as_argument(&self) -> Result<Option<FunctionArgument>, String> {
+        match *self {
+            syn::FnArg::Typed(syn::PatType {
+                ref pat, ref ty, ..
+            }) => {
+                let name = match **pat {
+                    syn::Pat::Wild(..) => None,
+                    syn::Pat::Ident(syn::PatIdent { ref ident, .. }) => {
+                        Some(ident.unraw().to_string())
+                    }
+                    _ => {
+                        return Err(format!(
+                            "Parameter has an unsupported argument name: {:?}",
+                            pat
+                        ))
+                    }
+                };
+                let ty = match Type::load(ty)? {
+                    Some(x) => x,
+                    None => return Ok(None),
+                };
+                if let Type::Array(..) = ty {
+                    return Err("Array as function arguments are not supported".to_owned());
+                }
+                Ok(Some(FunctionArgument {
+                    name,
+                    ty,
+                    array_length: None,
+                }))
+            }
+            syn::FnArg::Receiver(ref receiver) => Ok(Some(FunctionArgument {
+                name: Some("self".to_string()),
+                ty: gen_self_type(receiver),
+                array_length: None,
+            })),
+        }
+    }
+}
diff --git a/src/bindgen/ir/generic_path.rs b/src/bindgen/ir/generic_path.rs
new file mode 100644
index 0000000..ef14890
--- /dev/null
+++ b/src/bindgen/ir/generic_path.rs
@@ -0,0 +1,303 @@
+use std::io::Write;
+use std::ops::Deref;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::cdecl;
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::declarationtyperesolver::{DeclarationType, DeclarationTypeResolver};
+use crate::bindgen::ir::{ConstExpr, Path, Type};
+use crate::bindgen::utilities::IterHelpers;
+use crate::bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub enum GenericParamType {
+    Type,
+    Const(Type),
+}
+
+#[derive(Debug, Clone)]
+pub struct GenericParam {
+    name: Path,
+    ty: GenericParamType,
+}
+
+impl GenericParam {
+    pub fn new_type_param(name: &str) -> Self {
+        GenericParam {
+            name: Path::new(name),
+            ty: GenericParamType::Type,
+        }
+    }
+
+    pub fn load(param: &syn::GenericParam) -> Result<Option<Self>, String> {
+        match *param {
+            syn::GenericParam::Type(syn::TypeParam { ref ident, .. }) => Ok(Some(GenericParam {
+                name: Path::new(ident.unraw().to_string()),
+                ty: GenericParamType::Type,
+            })),
+
+            syn::GenericParam::Lifetime(_) => Ok(None),
+
+            syn::GenericParam::Const(syn::ConstParam {
+                ref ident, ref ty, ..
+            }) => match Type::load(ty)? {
+                None => {
+                    // A type that evaporates, like PhantomData.
+                    Err(format!("unsupported const generic type: {:?}", ty))
+                }
+                Some(ty) => Ok(Some(GenericParam {
+                    name: Path::new(ident.unraw().to_string()),
+                    ty: GenericParamType::Const(ty),
+                })),
+            },
+        }
+    }
+
+    pub fn name(&self) -> &Path {
+        &self.name
+    }
+}
+
+#[derive(Default, Debug, Clone)]
+pub struct GenericParams(pub Vec<GenericParam>);
+
+impl GenericParams {
+    pub fn load(generics: &syn::Generics) -> Result<Self, String> {
+        let mut params = vec![];
+        for param in &generics.params {
+            if let Some(p) = GenericParam::load(param)? {
+                params.push(p);
+            }
+        }
+
+        Ok(GenericParams(params))
+    }
+
+    /// Associate each parameter with an argument.
+    pub fn call<'out>(
+        &'out self,
+        item_name: &str,
+        arguments: &'out [GenericArgument],
+    ) -> Vec<(&'out Path, &'out GenericArgument)> {
+        assert!(self.len() > 0, "{} is not generic", item_name);
+        assert!(
+            self.len() == arguments.len(),
+            "{} has {} params but is being instantiated with {} values",
+            item_name,
+            self.len(),
+            arguments.len(),
+        );
+        self.iter()
+            .map(|param| param.name())
+            .zip(arguments.iter())
+            .collect()
+    }
+
+    fn write_internal<F: Write>(
+        &self,
+        config: &Config,
+        out: &mut SourceWriter<F>,
+        with_default: bool,
+    ) {
+        if !self.0.is_empty() && config.language == Language::Cxx {
+            out.write("template<");
+            for (i, item) in self.0.iter().enumerate() {
+                if i != 0 {
+                    out.write(", ");
+                }
+                match item.ty {
+                    GenericParamType::Type => {
+                        write!(out, "typename {}", item.name);
+                        if with_default {
+                            write!(out, " = void");
+                        }
+                    }
+                    GenericParamType::Const(ref ty) => {
+                        cdecl::write_field(out, ty, item.name.name(), config);
+                        if with_default {
+                            write!(out, " = 0");
+                        }
+                    }
+                }
+            }
+            out.write(">");
+            out.new_line();
+        }
+    }
+
+    pub fn write_with_default<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        self.write_internal(config, out, true);
+    }
+}
+
+impl Deref for GenericParams {
+    type Target = [GenericParam];
+
+    fn deref(&self) -> &[GenericParam] {
+        &self.0
+    }
+}
+
+impl Source for GenericParams {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        self.write_internal(config, out, false);
+    }
+}
+
+/// A (non-lifetime) argument passed to a generic, either a type or a constant expression.
+///
+/// Note: Both arguments in a type like `Array<T, N>` are represented as
+/// `GenericArgument::Type`s, even if `N` is actually the name of a const. This
+/// is a consequence of `syn::GenericArgument` doing the same thing.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum GenericArgument {
+    Type(Type),
+    Const(ConstExpr),
+}
+
+impl GenericArgument {
+    pub fn specialize(&self, mappings: &[(&Path, &GenericArgument)]) -> GenericArgument {
+        match *self {
+            GenericArgument::Type(ref ty) => {
+                if let Type::Path(ref path) = *ty {
+                    if path.is_single_identifier() {
+                        // See note on `GenericArgument` above: `ty` may
+                        // actually be the name of a const. Check for that now.
+                        for &(name, value) in mappings {
+                            if *name == path.path {
+                                return value.clone();
+                            }
+                        }
+                    }
+                }
+                GenericArgument::Type(ty.specialize(mappings))
+            }
+            GenericArgument::Const(ref expr) => GenericArgument::Const(expr.clone()),
+        }
+    }
+
+    pub fn rename_for_config(&mut self, config: &Config, generic_params: &GenericParams) {
+        match *self {
+            GenericArgument::Type(ref mut ty) => ty.rename_for_config(config, generic_params),
+            GenericArgument::Const(ref mut expr) => expr.rename_for_config(config),
+        }
+    }
+}
+
+impl Source for GenericArgument {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        match *self {
+            GenericArgument::Type(ref ty) => ty.write(config, out),
+            GenericArgument::Const(ref expr) => expr.write(config, out),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct GenericPath {
+    path: Path,
+    export_name: String,
+    generics: Vec<GenericArgument>,
+    ctype: Option<DeclarationType>,
+}
+
+impl GenericPath {
+    pub fn new(path: Path, generics: Vec<GenericArgument>) -> Self {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            generics,
+            ctype: None,
+        }
+    }
+
+    pub fn self_path() -> Self {
+        Self::new(Path::new("Self"), vec![])
+    }
+
+    pub fn replace_self_with(&mut self, self_ty: &Path) {
+        if self.path.replace_self_with(self_ty) {
+            self.export_name = self_ty.name().to_owned();
+        }
+        // Caller deals with generics.
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+
+    pub fn generics(&self) -> &[GenericArgument] {
+        &self.generics
+    }
+
+    pub fn generics_mut(&mut self) -> &mut [GenericArgument] {
+        &mut self.generics
+    }
+
+    pub fn ctype(&self) -> Option<&DeclarationType> {
+        self.ctype.as_ref()
+    }
+
+    pub fn name(&self) -> &str {
+        self.path.name()
+    }
+
+    pub fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    pub fn is_single_identifier(&self) -> bool {
+        self.generics.is_empty()
+    }
+
+    pub fn rename_for_config(&mut self, config: &Config, generic_params: &GenericParams) {
+        for generic in &mut self.generics {
+            generic.rename_for_config(config, generic_params);
+        }
+        if !generic_params.iter().any(|param| param.name == self.path) {
+            config.export.rename(&mut self.export_name);
+        }
+    }
+
+    pub fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        self.ctype = resolver.type_for(&self.path);
+    }
+
+    pub fn load(path: &syn::Path) -> Result<Self, String> {
+        assert!(
+            !path.segments.is_empty(),
+            "{:?} doesn't have any segments",
+            path
+        );
+        let last_segment = path.segments.last().unwrap();
+        let name = last_segment.ident.unraw().to_string();
+
+        let path = Path::new(name);
+        let phantom_data_path = Path::new("PhantomData");
+        if path == phantom_data_path {
+            return Ok(Self::new(path, Vec::new()));
+        }
+
+        let generics = match last_segment.arguments {
+            syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
+                ref args,
+                ..
+            }) => args.iter().try_skip_map(|x| match *x {
+                syn::GenericArgument::Type(ref x) => Ok(Type::load(x)?.map(GenericArgument::Type)),
+                syn::GenericArgument::Lifetime(_) => Ok(None),
+                syn::GenericArgument::Const(ref x) => {
+                    Ok(Some(GenericArgument::Const(ConstExpr::load(x)?)))
+                }
+                _ => Err(format!("can't handle generic argument {:?}", x)),
+            })?,
+            syn::PathArguments::Parenthesized(_) => {
+                return Err("Path contains parentheses.".to_owned());
+            }
+            _ => Vec::new(),
+        };
+
+        Ok(Self::new(path, generics))
+    }
+}
diff --git a/src/bindgen/ir/global.rs b/src/bindgen/ir/global.rs
new file mode 100644
index 0000000..82a1756
--- /dev/null
+++ b/src/bindgen/ir/global.rs
@@ -0,0 +1,121 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use crate::bindgen::cdecl;
+use crate::bindgen::config::Config;
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{AnnotationSet, Cfg, Documentation, Item, ItemContainer, Path, Type};
+use crate::bindgen::library::Library;
+use crate::bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct Static {
+    pub path: Path,
+    pub export_name: String,
+    pub ty: Type,
+    pub mutable: bool,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+}
+
+impl Static {
+    pub fn load(
+        path: Path,
+        item: &syn::ItemStatic,
+        mod_cfg: Option<&Cfg>,
+    ) -> Result<Static, String> {
+        let ty = Type::load(&item.ty)?;
+
+        if ty.is_none() {
+            return Err("Cannot have a zero sized static definition.".to_owned());
+        }
+
+        Ok(Static::new(
+            path,
+            ty.unwrap(),
+            item.mutability.is_some(),
+            Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
+            AnnotationSet::load(&item.attrs)?,
+            Documentation::load(&item.attrs),
+        ))
+    }
+
+    pub fn new(
+        path: Path,
+        ty: Type,
+        mutable: bool,
+        cfg: Option<Cfg>,
+        annotations: AnnotationSet,
+        documentation: Documentation,
+    ) -> Self {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            ty,
+            mutable,
+            cfg,
+            annotations,
+            documentation,
+        }
+    }
+
+    pub fn simplify_standard_types(&mut self, config: &Config) {
+        self.ty.simplify_standard_types(config);
+    }
+}
+
+impl Item for Static {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    fn cfg(&self) -> Option<&Cfg> {
+        self.cfg.as_ref()
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::Static(self.clone())
+    }
+
+    fn rename_for_config(&mut self, config: &Config) {
+        self.ty.rename_for_config(config, &Default::default());
+    }
+
+    fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        self.ty.resolve_declaration_types(resolver);
+    }
+
+    fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        self.ty.add_dependencies(library, out);
+    }
+}
+
+impl Source for Static {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        out.write("extern ");
+        if let Type::Ptr { is_const: true, .. } = self.ty {
+        } else if !self.mutable {
+            out.write("const ");
+        }
+        cdecl::write_field(out, &self.ty, &self.export_name, config);
+        out.write(";");
+    }
+}
diff --git a/src/bindgen/ir/item.rs b/src/bindgen/ir/item.rs
new file mode 100644
index 0000000..16d98f5
--- /dev/null
+++ b/src/bindgen/ir/item.rs
@@ -0,0 +1,250 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use indexmap::IndexMap;
+use std::mem;
+
+use crate::bindgen::config::Config;
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, Constant, Enum, GenericArgument, OpaqueItem, Path, Static, Struct, Typedef,
+    Union,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::monomorph::Monomorphs;
+
+/// An item is any type of rust item besides a function
+pub trait Item {
+    fn path(&self) -> &Path;
+    fn name(&self) -> &str {
+        self.path().name()
+    }
+    fn export_name(&self) -> &str {
+        self.name()
+    }
+    fn cfg(&self) -> Option<&Cfg>;
+    fn annotations(&self) -> &AnnotationSet;
+    fn annotations_mut(&mut self) -> &mut AnnotationSet;
+
+    fn container(&self) -> ItemContainer;
+
+    fn collect_declaration_types(&self, _resolver: &mut DeclarationTypeResolver) {
+        unimplemented!()
+    }
+    fn resolve_declaration_types(&mut self, _resolver: &DeclarationTypeResolver) {
+        unimplemented!()
+    }
+    fn rename_for_config(&mut self, _config: &Config) {}
+    fn add_dependencies(&self, _library: &Library, _out: &mut Dependencies) {}
+    fn instantiate_monomorph(
+        &self,
+        _generics: &[GenericArgument],
+        _library: &Library,
+        _out: &mut Monomorphs,
+    ) {
+        unreachable!("Cannot instantiate {} as a generic.", self.name())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ItemContainer {
+    Constant(Constant),
+    Static(Static),
+    OpaqueItem(OpaqueItem),
+    Struct(Struct),
+    Union(Union),
+    Enum(Enum),
+    Typedef(Typedef),
+}
+
+impl ItemContainer {
+    pub fn deref(&self) -> &dyn Item {
+        match *self {
+            ItemContainer::Constant(ref x) => x,
+            ItemContainer::Static(ref x) => x,
+            ItemContainer::OpaqueItem(ref x) => x,
+            ItemContainer::Struct(ref x) => x,
+            ItemContainer::Union(ref x) => x,
+            ItemContainer::Enum(ref x) => x,
+            ItemContainer::Typedef(ref x) => x,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ItemValue<T: Item> {
+    Cfg(Vec<T>),
+    Single(T),
+}
+
+#[derive(Debug, Clone)]
+pub struct ItemMap<T: Item> {
+    data: IndexMap<Path, ItemValue<T>>,
+}
+
+impl<T: Item> Default for ItemMap<T> {
+    fn default() -> ItemMap<T> {
+        ItemMap {
+            data: Default::default(),
+        }
+    }
+}
+
+impl<T: Item + Clone> ItemMap<T> {
+    pub fn rebuild(&mut self) {
+        let old = mem::take(self);
+        old.for_all_items(|x| {
+            self.try_insert(x.clone());
+        });
+    }
+
+    pub fn try_insert(&mut self, item: T) -> bool {
+        match (item.cfg().is_some(), self.data.get_mut(item.path())) {
+            (true, Some(&mut ItemValue::Cfg(ref mut items))) => {
+                items.push(item);
+                return true;
+            }
+            (false, Some(&mut ItemValue::Cfg(_))) => {
+                return false;
+            }
+            (true, Some(&mut ItemValue::Single(_))) => {
+                return false;
+            }
+            (false, Some(&mut ItemValue::Single(_))) => {
+                return false;
+            }
+            _ => {}
+        }
+
+        let path = item.path().clone();
+        if item.cfg().is_some() {
+            self.data.insert(path, ItemValue::Cfg(vec![item]));
+        } else {
+            self.data.insert(path, ItemValue::Single(item));
+        }
+
+        true
+    }
+
+    pub fn extend_with(&mut self, other: &ItemMap<T>) {
+        other.for_all_items(|x| {
+            self.try_insert(x.clone());
+        });
+    }
+
+    pub fn to_vec(&self) -> Vec<T> {
+        let mut result = Vec::with_capacity(self.data.len());
+        for container in self.data.values() {
+            match *container {
+                ItemValue::Cfg(ref items) => result.extend_from_slice(items),
+                ItemValue::Single(ref item) => {
+                    result.push(item.clone());
+                }
+            }
+        }
+        result
+    }
+
+    pub fn get_items(&self, path: &Path) -> Option<Vec<ItemContainer>> {
+        Some(match *self.data.get(path)? {
+            ItemValue::Cfg(ref items) => items.iter().map(|x| x.container()).collect(),
+            ItemValue::Single(ref item) => vec![item.container()],
+        })
+    }
+
+    pub fn filter<F>(&mut self, callback: F)
+    where
+        F: Fn(&T) -> bool,
+    {
+        let data = mem::take(&mut self.data);
+
+        for (name, container) in data {
+            match container {
+                ItemValue::Cfg(items) => {
+                    let mut new_items = Vec::new();
+                    for item in items {
+                        if !callback(&item) {
+                            new_items.push(item);
+                        }
+                    }
+                    if !new_items.is_empty() {
+                        self.data.insert(name, ItemValue::Cfg(new_items));
+                    }
+                }
+                ItemValue::Single(item) => {
+                    if !callback(&item) {
+                        self.data.insert(name, ItemValue::Single(item));
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn for_all_items<F>(&self, mut callback: F)
+    where
+        F: FnMut(&T),
+    {
+        for container in self.data.values() {
+            match *container {
+                ItemValue::Cfg(ref items) => {
+                    for item in items {
+                        callback(item);
+                    }
+                }
+                ItemValue::Single(ref item) => callback(item),
+            }
+        }
+    }
+
+    pub fn for_all_items_mut<F>(&mut self, mut callback: F)
+    where
+        F: FnMut(&mut T),
+    {
+        for container in self.data.values_mut() {
+            match *container {
+                ItemValue::Cfg(ref mut items) => {
+                    for item in items {
+                        callback(item);
+                    }
+                }
+                ItemValue::Single(ref mut item) => callback(item),
+            }
+        }
+    }
+
+    pub fn for_items<F>(&self, path: &Path, mut callback: F)
+    where
+        F: FnMut(&T),
+    {
+        match self.data.get(path) {
+            Some(ItemValue::Cfg(items)) => {
+                for item in items {
+                    callback(item);
+                }
+            }
+            Some(ItemValue::Single(item)) => {
+                callback(item);
+            }
+            None => {}
+        }
+    }
+
+    pub fn for_items_mut<F>(&mut self, path: &Path, mut callback: F)
+    where
+        F: FnMut(&mut T),
+    {
+        match self.data.get_mut(path) {
+            Some(&mut ItemValue::Cfg(ref mut items)) => {
+                for item in items {
+                    callback(item);
+                }
+            }
+            Some(&mut ItemValue::Single(ref mut item)) => {
+                callback(item);
+            }
+            None => {}
+        }
+    }
+}
diff --git a/src/bindgen/ir/mod.rs b/src/bindgen/ir/mod.rs
new file mode 100644
index 0000000..3566f0d
--- /dev/null
+++ b/src/bindgen/ir/mod.rs
@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+pub mod annotation;
+pub mod cfg;
+pub mod constant;
+pub mod documentation;
+pub mod enumeration;
+pub mod field;
+pub mod function;
+pub mod generic_path;
+pub mod global;
+pub mod item;
+pub mod opaque;
+pub mod path;
+pub mod repr;
+pub mod structure;
+pub mod ty;
+pub mod typedef;
+pub mod union;
+
+pub use self::annotation::{AnnotationSet, AnnotationValue, DeprecatedNoteKind};
+pub use self::cfg::*;
+pub use self::constant::*;
+pub use self::documentation::Documentation;
+pub use self::enumeration::*;
+pub use self::field::*;
+pub use self::function::*;
+pub use self::generic_path::*;
+pub use self::global::*;
+pub use self::item::*;
+pub use self::opaque::*;
+pub use self::path::*;
+pub use self::repr::*;
+pub use self::structure::*;
+pub use self::ty::*;
+pub use self::typedef::*;
+pub use self::union::*;
diff --git a/src/bindgen/ir/opaque.rs b/src/bindgen/ir/opaque.rs
new file mode 100644
index 0000000..4451d4a
--- /dev/null
+++ b/src/bindgen/ir/opaque.rs
@@ -0,0 +1,176 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, ConditionWrite, Documentation, GenericArgument, GenericParams, Item,
+    ItemContainer, Path, ToCondition,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::mangle;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct OpaqueItem {
+    pub path: Path,
+    pub export_name: String,
+    pub generic_params: GenericParams,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+}
+
+impl OpaqueItem {
+    pub fn load(
+        path: Path,
+        generics: &syn::Generics,
+        attrs: &[syn::Attribute],
+        mod_cfg: Option<&Cfg>,
+    ) -> Result<OpaqueItem, String> {
+        Ok(Self::new(
+            path,
+            GenericParams::load(generics)?,
+            Cfg::append(mod_cfg, Cfg::load(attrs)),
+            AnnotationSet::load(attrs).unwrap_or_else(|_| AnnotationSet::new()),
+            Documentation::load(attrs),
+        ))
+    }
+
+    pub fn new(
+        path: Path,
+        generic_params: GenericParams,
+        cfg: Option<Cfg>,
+        annotations: AnnotationSet,
+        documentation: Documentation,
+    ) -> OpaqueItem {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            generic_params,
+            cfg,
+            annotations,
+            documentation,
+        }
+    }
+}
+
+impl Item for OpaqueItem {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    fn cfg(&self) -> Option<&Cfg> {
+        self.cfg.as_ref()
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::OpaqueItem(self.clone())
+    }
+
+    fn collect_declaration_types(&self, resolver: &mut DeclarationTypeResolver) {
+        resolver.add_struct(&self.path);
+    }
+
+    fn rename_for_config(&mut self, config: &Config) {
+        config.export.rename(&mut self.export_name);
+    }
+
+    fn add_dependencies(&self, _: &Library, _: &mut Dependencies) {}
+
+    fn instantiate_monomorph(
+        &self,
+        generic_values: &[GenericArgument],
+        library: &Library,
+        out: &mut Monomorphs,
+    ) {
+        assert!(
+            !self.generic_params.is_empty(),
+            "{} is not generic",
+            self.path
+        );
+
+        // We can be instantiated with less generic params because of default
+        // template parameters, or because of empty types that we remove during
+        // parsing (`()`).
+        assert!(
+            self.generic_params.len() >= generic_values.len(),
+            "{} has {} params but is being instantiated with {} values",
+            self.path,
+            self.generic_params.len(),
+            generic_values.len(),
+        );
+
+        let mangled_path = mangle::mangle_path(
+            &self.path,
+            generic_values,
+            &library.get_config().export.mangle,
+        );
+
+        let monomorph = OpaqueItem::new(
+            mangled_path,
+            GenericParams::default(),
+            self.cfg.clone(),
+            self.annotations.clone(),
+            self.documentation.clone(),
+        );
+
+        out.insert_opaque(self, monomorph, generic_values.to_owned());
+    }
+}
+
+impl Source for OpaqueItem {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        let condition = self.cfg.to_condition(config);
+        condition.write_before(config, out);
+
+        self.documentation.write(config, out);
+
+        self.generic_params.write_with_default(config, out);
+
+        match config.language {
+            Language::C if config.style.generate_typedef() => {
+                write!(
+                    out,
+                    "typedef struct {} {};",
+                    self.export_name(),
+                    self.export_name()
+                );
+            }
+            Language::C | Language::Cxx => {
+                write!(out, "struct {};", self.export_name());
+            }
+            Language::Cython => {
+                write!(
+                    out,
+                    "{}struct {}",
+                    config.style.cython_def(),
+                    self.export_name()
+                );
+                out.open_brace();
+                out.write("pass");
+                out.close_brace(false);
+            }
+        }
+
+        condition.write_after(config, out);
+    }
+}
diff --git a/src/bindgen/ir/path.rs b/src/bindgen/ir/path.rs
new file mode 100644
index 0000000..480c31b
--- /dev/null
+++ b/src/bindgen/ir/path.rs
@@ -0,0 +1,50 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::cmp::Ordering;
+use std::fmt;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Path {
+    name: String,
+}
+
+impl Path {
+    pub fn new<T>(name: T) -> Self
+    where
+        String: From<T>,
+    {
+        Self { name: name.into() }
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn replace_self_with(&mut self, path: &Self) -> bool {
+        if self.name() != "Self" {
+            return false;
+        }
+        *self = path.clone();
+        true
+    }
+}
+
+impl PartialOrd for Path {
+    fn partial_cmp(&self, other: &Path) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Path {
+    fn cmp(&self, other: &Path) -> Ordering {
+        self.name.cmp(&other.name)
+    }
+}
+
+impl fmt::Display for Path {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
diff --git a/src/bindgen/ir/repr.rs b/src/bindgen/ir/repr.rs
new file mode 100644
index 0000000..c40cd7f
--- /dev/null
+++ b/src/bindgen/ir/repr.rs
@@ -0,0 +1,182 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::ir::ty::{IntKind, PrimitiveType};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+pub enum ReprStyle {
+    #[default]
+    Rust,
+    C,
+    Transparent,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ReprType {
+    kind: IntKind,
+    signed: bool,
+}
+
+impl ReprType {
+    pub(crate) fn to_primitive(self) -> PrimitiveType {
+        PrimitiveType::Integer {
+            kind: self.kind,
+            signed: self.signed,
+            zeroable: true,
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ReprAlign {
+    Packed,
+    Align(u64),
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+pub struct Repr {
+    pub style: ReprStyle,
+    pub ty: Option<ReprType>,
+    pub align: Option<ReprAlign>,
+}
+
+impl Repr {
+    pub fn load(attrs: &[syn::Attribute]) -> Result<Repr, String> {
+        let ids = attrs
+            .iter()
+            .filter_map(|attr| {
+                if let syn::Meta::List(syn::MetaList { path, nested, .. }) =
+                    attr.parse_meta().ok()?
+                {
+                    if path.is_ident("repr") {
+                        return Some(nested.into_iter().collect::<Vec<_>>());
+                    }
+                }
+                None
+            })
+            .flatten()
+            .filter_map(|meta| match meta {
+                syn::NestedMeta::Meta(syn::Meta::Path(path)) => Some((
+                    path.segments.first().unwrap().ident.unraw().to_string(),
+                    None,
+                )),
+                syn::NestedMeta::Meta(syn::Meta::List(syn::MetaList { path, nested, .. })) => {
+                    Some((
+                        path.segments.first().unwrap().ident.unraw().to_string(),
+                        Some(
+                            nested
+                                .iter()
+                                .filter_map(|meta| match meta {
+                                    // Only used for #[repr(align(...))].
+                                    syn::NestedMeta::Lit(syn::Lit::Int(literal)) => {
+                                        Some(literal.base10_digits().to_string())
+                                    }
+                                    // Only single levels of nesting supported at the moment.
+                                    _ => None,
+                                })
+                                .collect::<Vec<_>>(),
+                        ),
+                    ))
+                }
+                _ => None,
+            });
+
+        let mut repr = Repr::default();
+        for id in ids {
+            let (int_kind, signed) = match (id.0.as_ref(), id.1) {
+                ("u8", None) => (IntKind::B8, false),
+                ("u16", None) => (IntKind::B16, false),
+                ("u32", None) => (IntKind::B32, false),
+                ("u64", None) => (IntKind::B64, false),
+                ("usize", None) => (IntKind::Size, false),
+                ("i8", None) => (IntKind::B8, true),
+                ("i16", None) => (IntKind::B16, true),
+                ("i32", None) => (IntKind::B32, true),
+                ("i64", None) => (IntKind::B64, true),
+                ("isize", None) => (IntKind::Size, true),
+                ("C", None) => {
+                    repr.style = ReprStyle::C;
+                    continue;
+                }
+                ("transparent", None) => {
+                    repr.style = ReprStyle::Transparent;
+                    continue;
+                }
+                ("packed", args) => {
+                    // #[repr(packed(n))] not supported because of some open questions about how
+                    // to calculate the native alignment of types. See mozilla/cbindgen#433.
+                    if args.is_some() {
+                        return Err(
+                            "Not-yet-implemented #[repr(packed(...))] encountered.".to_string()
+                        );
+                    }
+                    let align = ReprAlign::Packed;
+                    // Only permit a single alignment-setting repr.
+                    if let Some(old_align) = repr.align {
+                        return Err(format!(
+                            "Conflicting #[repr(align(...))] type hints {:?} and {:?}.",
+                            old_align, align
+                        ));
+                    }
+                    repr.align = Some(align);
+                    continue;
+                }
+                ("align", Some(args)) => {
+                    // #[repr(align(...))] only allows a single argument.
+                    if args.len() != 1 {
+                        return Err(format!(
+                            "Unsupported #[repr(align({}))], align must have exactly one argument.",
+                            args.join(", ")
+                        ));
+                    }
+                    // Must be a positive integer.
+                    let align = match args.first().unwrap().parse::<u64>() {
+                        Ok(align) => align,
+                        Err(_) => {
+                            return Err(format!("Non-numeric #[repr(align({}))].", args.join(", ")))
+                        }
+                    };
+                    // Must be a power of 2.
+                    if !align.is_power_of_two() || align == 0 {
+                        return Err(format!("Invalid alignment to #[repr(align({}))].", align));
+                    }
+                    // Only permit a single alignment-setting repr.
+                    if let Some(old_align) = repr.align {
+                        return Err(format!(
+                            "Conflicting #[repr(align(...))] type hints {:?} and {:?}.",
+                            old_align,
+                            ReprAlign::Align(align)
+                        ));
+                    }
+                    repr.align = Some(ReprAlign::Align(align));
+                    continue;
+                }
+                (path, args) => match args {
+                    None => return Err(format!("Unsupported #[repr({})].", path)),
+                    Some(args) => {
+                        return Err(format!(
+                            "Unsupported #[repr({}({}))].",
+                            path,
+                            args.join(", ")
+                        ));
+                    }
+                },
+            };
+            let ty = ReprType {
+                kind: int_kind,
+                signed,
+            };
+            if let Some(old_ty) = repr.ty {
+                return Err(format!(
+                    "Conflicting #[repr(...)] type hints {:?} and {:?}.",
+                    old_ty, ty
+                ));
+            }
+            repr.ty = Some(ty);
+        }
+        Ok(repr)
+    }
+}
diff --git a/src/bindgen/ir/structure.rs b/src/bindgen/ir/structure.rs
new file mode 100644
index 0000000..2eefa95
--- /dev/null
+++ b/src/bindgen/ir/structure.rs
@@ -0,0 +1,717 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::config::{Config, Language, LayoutConfig};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, ConditionWrite, Constant, DeprecatedNoteKind, Documentation, Field,
+    GenericArgument, GenericParams, Item, ItemContainer, Path, Repr, ReprAlign, ReprStyle,
+    ToCondition, Type, Typedef,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::mangle;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::rename::{IdentifierType, RenameRule};
+use crate::bindgen::reserved;
+use crate::bindgen::utilities::IterHelpers;
+use crate::bindgen::writer::{ListType, Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct Struct {
+    pub path: Path,
+    pub export_name: String,
+    pub generic_params: GenericParams,
+    pub fields: Vec<Field>,
+    /// Whether there's a tag field on the body of this struct. When this is
+    /// true, is_enum_variant_body is also guaranteed to be true.
+    pub has_tag_field: bool,
+    /// Whether this is an enum variant body.
+    pub is_enum_variant_body: bool,
+    pub alignment: Option<ReprAlign>,
+    pub is_transparent: bool,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+    pub associated_constants: Vec<Constant>,
+}
+
+impl Struct {
+    /// Whether this struct can derive operator== / operator!=.
+    pub fn can_derive_eq(&self) -> bool {
+        !self.fields.is_empty() && self.fields.iter().all(|x| x.ty.can_cmp_eq())
+    }
+
+    pub fn add_associated_constant(&mut self, c: Constant) {
+        self.associated_constants.push(c);
+    }
+
+    pub fn load(
+        layout_config: &LayoutConfig,
+        item: &syn::ItemStruct,
+        mod_cfg: Option<&Cfg>,
+    ) -> Result<Self, String> {
+        let repr = Repr::load(&item.attrs)?;
+        let is_transparent = match repr.style {
+            ReprStyle::C => false,
+            ReprStyle::Transparent => true,
+            _ => {
+                return Err("Struct is not marked #[repr(C)] or #[repr(transparent)].".to_owned());
+            }
+        };
+
+        let path = Path::new(item.ident.unraw().to_string());
+
+        // Ensure we can safely represent the struct given the configuration.
+        if let Some(align) = repr.align {
+            layout_config.ensure_safe_to_represent(&align)?;
+        }
+
+        let fields = match item.fields {
+            syn::Fields::Unit => Vec::new(),
+            syn::Fields::Named(ref fields) => fields
+                .named
+                .iter()
+                .try_skip_map(|field| Field::load(field, &path))?,
+            syn::Fields::Unnamed(ref fields) => {
+                let mut out = Vec::new();
+                let mut current = 0;
+                for field in fields.unnamed.iter() {
+                    if let Some(mut ty) = Type::load(&field.ty)? {
+                        ty.replace_self_with(&path);
+                        out.push(Field {
+                            name: format!("{}", current),
+                            ty,
+                            cfg: Cfg::load(&field.attrs),
+                            annotations: AnnotationSet::load(&field.attrs)?,
+                            documentation: Documentation::load(&field.attrs),
+                        });
+                        current += 1;
+                    }
+                }
+                out
+            }
+        };
+
+        let has_tag_field = false;
+        let is_enum_variant_body = false;
+
+        Ok(Struct::new(
+            path,
+            GenericParams::load(&item.generics)?,
+            fields,
+            has_tag_field,
+            is_enum_variant_body,
+            repr.align,
+            is_transparent,
+            Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
+            AnnotationSet::load(&item.attrs)?,
+            Documentation::load(&item.attrs),
+        ))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        path: Path,
+        generic_params: GenericParams,
+        fields: Vec<Field>,
+        has_tag_field: bool,
+        is_enum_variant_body: bool,
+        alignment: Option<ReprAlign>,
+        is_transparent: bool,
+        cfg: Option<Cfg>,
+        annotations: AnnotationSet,
+        documentation: Documentation,
+    ) -> Self {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            generic_params,
+            fields,
+            has_tag_field,
+            is_enum_variant_body,
+            alignment,
+            is_transparent,
+            cfg,
+            annotations,
+            documentation,
+            associated_constants: vec![],
+        }
+    }
+
+    pub fn simplify_standard_types(&mut self, config: &Config) {
+        for field in &mut self.fields {
+            field.ty.simplify_standard_types(config);
+        }
+    }
+
+    pub fn is_generic(&self) -> bool {
+        self.generic_params.len() > 0
+    }
+
+    pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+        // Generic structs can instantiate monomorphs only once they've been
+        // instantiated. See `instantiate_monomorph` for more details.
+        if self.is_generic() {
+            return;
+        }
+
+        for field in &self.fields {
+            field.ty.add_monomorphs(library, out);
+        }
+    }
+
+    pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+        for field in &mut self.fields {
+            field.ty.mangle_paths(monomorphs);
+        }
+    }
+
+    pub fn specialize(
+        &self,
+        generic_values: &[GenericArgument],
+        mappings: &[(&Path, &GenericArgument)],
+        config: &Config,
+    ) -> Self {
+        let mangled_path = mangle::mangle_path(&self.path, generic_values, &config.export.mangle);
+        Struct::new(
+            mangled_path,
+            GenericParams::default(),
+            self.fields
+                .iter()
+                .map(|field| Field {
+                    name: field.name.clone(),
+                    ty: field.ty.specialize(mappings),
+                    cfg: field.cfg.clone(),
+                    annotations: field.annotations.clone(),
+                    documentation: field.documentation.clone(),
+                })
+                .collect(),
+            self.has_tag_field,
+            self.is_enum_variant_body,
+            self.alignment,
+            self.is_transparent,
+            self.cfg.clone(),
+            self.annotations.clone(),
+            self.documentation.clone(),
+        )
+    }
+
+    fn emit_bitflags_binop<F: Write>(
+        &self,
+        constexpr_prefix: &str,
+        operator: char,
+        other: &str,
+        out: &mut SourceWriter<F>,
+    ) {
+        let bits = &self.fields[0].name;
+        out.new_line();
+        write!(
+            out,
+            "{}{} operator{}(const {}& {}) const",
+            constexpr_prefix,
+            self.export_name(),
+            operator,
+            self.export_name(),
+            other
+        );
+        out.open_brace();
+        write!(
+            out,
+            "return {} {{ static_cast<decltype({bits})>(this->{bits} {operator} {other}.{bits}) }};",
+            self.export_name()
+        );
+        out.close_brace(false);
+
+        out.new_line();
+        write!(
+            out,
+            "{}& operator{}=(const {}& {})",
+            self.export_name(),
+            operator,
+            self.export_name(),
+            other
+        );
+        out.open_brace();
+        write!(out, "*this = (*this {} {});", operator, other);
+        out.new_line();
+        write!(out, "return *this;");
+        out.close_brace(false);
+    }
+}
+
+impl Item for Struct {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    fn cfg(&self) -> Option<&Cfg> {
+        self.cfg.as_ref()
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::Struct(self.clone())
+    }
+
+    fn collect_declaration_types(&self, resolver: &mut DeclarationTypeResolver) {
+        if self.is_transparent {
+            resolver.add_none(&self.path);
+        } else {
+            resolver.add_struct(&self.path);
+        }
+    }
+
+    fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        for field in &mut self.fields {
+            field.ty.resolve_declaration_types(resolver);
+        }
+    }
+
+    fn rename_for_config(&mut self, config: &Config) {
+        // Rename the name of the struct
+        if !(self.has_tag_field && config.language == Language::Cxx) {
+            config.export.rename(&mut self.export_name);
+        }
+
+        // Rename the types used in fields
+        {
+            let fields = self.fields.iter_mut().skip(self.has_tag_field as usize);
+            for field in fields {
+                field.ty.rename_for_config(config, &self.generic_params);
+            }
+        }
+
+        // Apply renaming rules to fields in the following order
+        //   1. `cbindgen::field-names` annotation
+        //   2. `cbindgen::rename-all` annotation
+        //   3. config struct rename rule
+        // If the struct is a tuple struct and we have not renamed the
+        // fields, then prefix each of them with an underscore.
+        // If any field is a reserved keyword, then postfix it with an
+        // underscore.
+
+        // Scope for mutable borrow of fields
+        {
+            let names = self.fields.iter_mut().map(|field| &mut field.name);
+
+            let field_rules = self
+                .annotations
+                .parse_atom::<RenameRule>("rename-all")
+                .unwrap_or(config.structure.rename_fields);
+
+            if let Some(o) = self.annotations.list("field-names") {
+                for (dest, src) in names.zip(o) {
+                    *dest = src;
+                }
+            } else if let Some(r) = field_rules.not_none() {
+                for name in names {
+                    *name = r.apply(name, IdentifierType::StructMember).into_owned();
+                }
+            } else {
+                // If we don't have any rules for a tuple struct, prefix them with
+                // an underscore so it still compiles.
+                for name in names {
+                    if name.starts_with(|c: char| c.is_ascii_digit()) {
+                        name.insert(0, '_');
+                    }
+                }
+            }
+        }
+
+        for field in &mut self.fields {
+            reserved::escape(&mut field.name);
+        }
+
+        for c in self.associated_constants.iter_mut() {
+            c.rename_for_config(config);
+        }
+    }
+
+    fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        let mut fields = self.fields.iter();
+
+        // If there is a tag field, skip it
+        if self.has_tag_field {
+            fields.next();
+        }
+
+        for field in fields {
+            field
+                .ty
+                .add_dependencies_ignoring_generics(&self.generic_params, library, out);
+        }
+
+        for c in &self.associated_constants {
+            c.add_dependencies(library, out);
+        }
+    }
+
+    fn instantiate_monomorph(
+        &self,
+        generic_values: &[GenericArgument],
+        library: &Library,
+        out: &mut Monomorphs,
+    ) {
+        let mappings = self.generic_params.call(self.path.name(), generic_values);
+        let monomorph = self.specialize(generic_values, &mappings, library.get_config());
+        out.insert_struct(library, self, monomorph, generic_values.to_owned());
+    }
+}
+
+impl Source for Struct {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        if self.is_transparent {
+            let typedef = Typedef {
+                path: self.path.clone(),
+                export_name: self.export_name.to_owned(),
+                generic_params: self.generic_params.clone(),
+                aliased: self.fields[0].ty.clone(),
+                cfg: self.cfg.clone(),
+                annotations: self.annotations.clone(),
+                documentation: self.documentation.clone(),
+            };
+            typedef.write(config, out);
+            for constant in &self.associated_constants {
+                out.new_line();
+                constant.write(config, out, Some(self));
+            }
+            return;
+        }
+
+        let condition = self.cfg.to_condition(config);
+        condition.write_before(config, out);
+
+        self.documentation.write(config, out);
+
+        if !self.is_enum_variant_body {
+            self.generic_params.write(config, out);
+        }
+
+        // The following results in
+        // C++ or C with Tag as style:
+        //   struct Name {
+        // C with Type only style:
+        //   typedef struct {
+        // C with Both as style:
+        //   typedef struct Name {
+        match config.language {
+            Language::C if config.style.generate_typedef() => out.write("typedef "),
+            Language::C | Language::Cxx => {}
+            Language::Cython => out.write(config.style.cython_def()),
+        }
+
+        // Cython extern declarations don't manage layouts, layouts are defined entierly by the
+        // corresponding C code. So this `packed` is only for documentation, and missing
+        // `aligned(n)` is also not a problem.
+        if config.language == Language::Cython {
+            if let Some(align) = self.alignment {
+                match align {
+                    ReprAlign::Packed => out.write("packed "),
+                    ReprAlign::Align(_) => {} // Not supported
+                }
+            }
+        }
+
+        out.write("struct");
+
+        if config.language != Language::Cython {
+            if let Some(align) = self.alignment {
+                match align {
+                    ReprAlign::Packed => {
+                        if let Some(ref anno) = config.layout.packed {
+                            write!(out, " {}", anno);
+                        }
+                    }
+                    ReprAlign::Align(n) => {
+                        if let Some(ref anno) = config.layout.aligned_n {
+                            write!(out, " {}({})", anno, n);
+                        }
+                    }
+                }
+            }
+        }
+
+        if self.annotations.must_use(config) {
+            if let Some(ref anno) = config.structure.must_use {
+                write!(out, " {}", anno);
+            }
+        }
+        if let Some(note) = self
+            .annotations
+            .deprecated_note(config, DeprecatedNoteKind::Struct)
+        {
+            write!(out, " {}", note);
+        }
+
+        if config.language != Language::C || config.style.generate_tag() {
+            write!(out, " {}", self.export_name());
+        }
+
+        out.open_brace();
+
+        // Emit the pre_body section, if relevant
+        if let Some(body) = config.export.pre_body(&self.path) {
+            out.write_raw_block(body);
+            out.new_line();
+        }
+
+        out.write_vertical_source_list(&self.fields, ListType::Cap(";"));
+        if config.language == Language::Cython && self.fields.is_empty() {
+            out.write("pass");
+        }
+
+        if config.language == Language::Cxx {
+            let mut wrote_start_newline = false;
+
+            if config.structure.derive_constructor(&self.annotations) && !self.fields.is_empty() {
+                if !wrote_start_newline {
+                    wrote_start_newline = true;
+                    out.new_line();
+                }
+
+                out.new_line();
+
+                let arg_renamer = |name: &str| {
+                    config
+                        .function
+                        .rename_args
+                        .apply(name, IdentifierType::FunctionArg)
+                        .into_owned()
+                };
+                write!(out, "{}(", self.export_name());
+                let vec: Vec<_> = self
+                    .fields
+                    .iter()
+                    .map(|field| {
+                        Field::from_name_and_type(
+                            // const-ref args to constructor
+                            format!("const& {}", arg_renamer(&field.name)),
+                            field.ty.clone(),
+                        )
+                    })
+                    .collect();
+                out.write_vertical_source_list(&vec[..], ListType::Join(","));
+                write!(out, ")");
+                out.new_line();
+                write!(out, "  : ");
+                let vec: Vec<_> = self
+                    .fields
+                    .iter()
+                    .map(|field| format!("{}({})", field.name, arg_renamer(&field.name)))
+                    .collect();
+                out.write_vertical_source_list(&vec[..], ListType::Join(","));
+                out.new_line();
+                write!(out, "{{}}");
+                out.new_line();
+            }
+
+            let other = config
+                .function
+                .rename_args
+                .apply("other", IdentifierType::FunctionArg);
+
+            if self
+                .annotations
+                .bool("internal-derive-bitflags")
+                .unwrap_or(false)
+            {
+                assert_eq!(self.fields.len(), 1);
+                let bits = &self.fields[0].name;
+                if !wrote_start_newline {
+                    wrote_start_newline = true;
+                    out.new_line();
+                }
+                let constexpr_prefix = if config.constant.allow_constexpr {
+                    "constexpr "
+                } else {
+                    ""
+                };
+
+                out.new_line();
+                write!(out, "{}explicit operator bool() const", constexpr_prefix);
+                out.open_brace();
+                write!(out, "return !!{bits};");
+                out.close_brace(false);
+
+                out.new_line();
+                write!(
+                    out,
+                    "{}{} operator~() const",
+                    constexpr_prefix,
+                    self.export_name()
+                );
+                out.open_brace();
+                write!(
+                    out,
+                    "return {} {{ static_cast<decltype({bits})>(~{bits}) }};",
+                    self.export_name()
+                );
+                out.close_brace(false);
+                self.emit_bitflags_binop(constexpr_prefix, '|', &other, out);
+                self.emit_bitflags_binop(constexpr_prefix, '&', &other, out);
+                self.emit_bitflags_binop(constexpr_prefix, '^', &other, out);
+            }
+
+            // Generate a serializer function that allows dumping this struct
+            // to an std::ostream. It's defined as a friend function inside the
+            // struct definition, and doesn't need the `inline` keyword even
+            // though it's implemented right in the generated header file.
+            if config.structure.derive_ostream(&self.annotations) {
+                if !wrote_start_newline {
+                    wrote_start_newline = true;
+                    out.new_line();
+                }
+
+                out.new_line();
+                let stream = config
+                    .function
+                    .rename_args
+                    .apply("stream", IdentifierType::FunctionArg);
+                let instance = config
+                    .function
+                    .rename_args
+                    .apply("instance", IdentifierType::FunctionArg);
+                write!(
+                    out,
+                    "friend std::ostream& operator<<(std::ostream& {}, const {}& {})",
+                    stream,
+                    self.export_name(),
+                    instance,
+                );
+                out.open_brace();
+                write!(out, "return {} << \"{{ \"", stream);
+                let vec: Vec<_> = self
+                    .fields
+                    .iter()
+                    .map(|x| format!(" << \"{}=\" << {}.{}", x.name, instance, x.name))
+                    .collect();
+                out.write_vertical_source_list(&vec[..], ListType::Join(" << \", \""));
+                out.write(" << \" }\";");
+                out.close_brace(false);
+            }
+
+            let skip_fields = self.has_tag_field as usize;
+
+            macro_rules! emit_op {
+                ($op_name:expr, $op:expr, $conjuc:expr) => {{
+                    if !wrote_start_newline {
+                        #[allow(unused_assignments)]
+                        {
+                            wrote_start_newline = true;
+                        }
+                        out.new_line();
+                    }
+
+                    out.new_line();
+
+                    if let Some(Some(attrs)) =
+                        self.annotations.atom(concat!($op_name, "-attributes"))
+                    {
+                        write!(out, "{} ", attrs);
+                    }
+
+                    write!(
+                        out,
+                        "bool operator{}(const {}& {}) const",
+                        $op,
+                        self.export_name(),
+                        other
+                    );
+                    out.open_brace();
+                    out.write("return ");
+                    let vec: Vec<_> = self
+                        .fields
+                        .iter()
+                        .skip(skip_fields)
+                        .map(|field| format!("{} {} {}.{}", field.name, $op, other, field.name))
+                        .collect();
+                    out.write_vertical_source_list(
+                        &vec[..],
+                        ListType::Join(&format!(" {}", $conjuc)),
+                    );
+                    out.write(";");
+                    out.close_brace(false);
+                }};
+            }
+
+            if config.structure.derive_eq(&self.annotations) && self.can_derive_eq() {
+                emit_op!("eq", "==", "&&");
+            }
+            if config.structure.derive_neq(&self.annotations) && self.can_derive_eq() {
+                emit_op!("neq", "!=", "||");
+            }
+            if config.structure.derive_lt(&self.annotations)
+                && self.fields.len() == 1
+                && self.fields[0].ty.can_cmp_order()
+            {
+                emit_op!("lt", "<", "&&");
+            }
+            if config.structure.derive_lte(&self.annotations)
+                && self.fields.len() == 1
+                && self.fields[0].ty.can_cmp_order()
+            {
+                emit_op!("lte", "<=", "&&");
+            }
+            if config.structure.derive_gt(&self.annotations)
+                && self.fields.len() == 1
+                && self.fields[0].ty.can_cmp_order()
+            {
+                emit_op!("gt", ">", "&&");
+            }
+            if config.structure.derive_gte(&self.annotations)
+                && self.fields.len() == 1
+                && self.fields[0].ty.can_cmp_order()
+            {
+                emit_op!("gte", ">=", "&&");
+            }
+        }
+
+        // Emit the post_body section, if relevant
+        if let Some(body) = config.export.post_body(&self.path) {
+            out.new_line();
+            out.write_raw_block(body);
+        }
+
+        if config.language == Language::Cxx
+            && config.structure.associated_constants_in_body
+            && config.constant.allow_static_const
+        {
+            for constant in &self.associated_constants {
+                out.new_line();
+                constant.write_declaration(config, out, self);
+            }
+        }
+
+        if config.language == Language::C && config.style.generate_typedef() {
+            out.close_brace(false);
+            write!(out, " {};", self.export_name());
+        } else {
+            out.close_brace(true);
+        }
+
+        for constant in &self.associated_constants {
+            out.new_line();
+            constant.write(config, out, Some(self));
+        }
+
+        condition.write_after(config, out);
+    }
+}
diff --git a/src/bindgen/ir/ty.rs b/src/bindgen/ir/ty.rs
new file mode 100644
index 0000000..5a31fb6
--- /dev/null
+++ b/src/bindgen/ir/ty.rs
@@ -0,0 +1,1017 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::borrow::Cow;
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::cdecl;
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{GenericArgument, GenericParams, GenericPath, Path};
+use crate::bindgen::library::Library;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::utilities::IterHelpers;
+use crate::bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum PrimitiveType {
+    Void,
+    Bool,
+    Char,
+    SChar,
+    UChar,
+    Char32,
+    Float,
+    Double,
+    VaList,
+    PtrDiffT,
+    Integer {
+        zeroable: bool,
+        signed: bool,
+        kind: IntKind,
+    },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum IntKind {
+    Short,
+    Int,
+    Long,
+    LongLong,
+    SizeT,
+    Size,
+    B8,
+    B16,
+    B32,
+    B64,
+}
+
+impl PrimitiveType {
+    pub fn maybe(path: &str) -> Option<PrimitiveType> {
+        Some(match path {
+            "c_void" => PrimitiveType::Void,
+            "c_char" => PrimitiveType::Char,
+            "c_schar" => PrimitiveType::SChar,
+            "c_uchar" => PrimitiveType::UChar,
+            "c_float" => PrimitiveType::Float,
+            "c_double" => PrimitiveType::Double,
+            "ptrdiff_t" => PrimitiveType::PtrDiffT,
+            "VaList" => PrimitiveType::VaList,
+            "bool" => PrimitiveType::Bool,
+            "char" => PrimitiveType::Char32,
+
+            "f32" => PrimitiveType::Float,
+            "f64" => PrimitiveType::Double,
+
+            _ => {
+                let (kind, signed) = match path {
+                    "c_short" => (IntKind::Short, true),
+                    "c_int" => (IntKind::Int, true),
+                    "c_long" => (IntKind::Long, true),
+                    "c_longlong" => (IntKind::LongLong, true),
+                    "ssize_t" => (IntKind::SizeT, true),
+                    "c_ushort" => (IntKind::Short, false),
+                    "c_uint" => (IntKind::Int, false),
+                    "c_ulong" => (IntKind::Long, false),
+                    "c_ulonglong" => (IntKind::LongLong, false),
+                    "size_t" => (IntKind::SizeT, false),
+                    "RawFd" => (IntKind::Int, true),
+
+                    "isize" | "intptr_t" => (IntKind::Size, true),
+                    "usize" | "uintptr_t" => (IntKind::Size, false),
+
+                    "u8" | "uint8_t" => (IntKind::B8, false),
+                    "u16" | "uint16_t" => (IntKind::B16, false),
+                    "u32" | "uint32_t" => (IntKind::B32, false),
+                    "u64" | "uint64_t" => (IntKind::B64, false),
+                    "i8" | "int8_t" => (IntKind::B8, true),
+                    "i16" | "int16_t" => (IntKind::B16, true),
+                    "i32" | "int32_t" => (IntKind::B32, true),
+                    "i64" | "int64_t" => (IntKind::B64, true),
+                    _ => return None,
+                };
+                PrimitiveType::Integer {
+                    zeroable: true,
+                    signed,
+                    kind,
+                }
+            }
+        })
+    }
+
+    pub fn to_repr_rust(&self) -> &'static str {
+        match *self {
+            PrimitiveType::Bool => "bool",
+            PrimitiveType::Void => "c_void",
+            PrimitiveType::Char => "c_char",
+            PrimitiveType::SChar => "c_schar",
+            PrimitiveType::UChar => "c_uchar",
+            PrimitiveType::Char32 => "char",
+            PrimitiveType::Integer {
+                kind,
+                signed,
+                zeroable: _,
+            } => match kind {
+                IntKind::Short => {
+                    if signed {
+                        "c_short"
+                    } else {
+                        "c_ushort"
+                    }
+                }
+                IntKind::Int => {
+                    if signed {
+                        "c_int"
+                    } else {
+                        "c_uint"
+                    }
+                }
+                IntKind::Long => {
+                    if signed {
+                        "c_long"
+                    } else {
+                        "c_ulong"
+                    }
+                }
+                IntKind::LongLong => {
+                    if signed {
+                        "c_longlong"
+                    } else {
+                        "c_ulonglong"
+                    }
+                }
+                IntKind::SizeT => {
+                    if signed {
+                        "ssize_t"
+                    } else {
+                        "size_t"
+                    }
+                }
+                IntKind::Size => {
+                    if signed {
+                        "isize"
+                    } else {
+                        "usize"
+                    }
+                }
+                IntKind::B8 => {
+                    if signed {
+                        "i8"
+                    } else {
+                        "u8"
+                    }
+                }
+                IntKind::B16 => {
+                    if signed {
+                        "i16"
+                    } else {
+                        "u16"
+                    }
+                }
+                IntKind::B32 => {
+                    if signed {
+                        "i32"
+                    } else {
+                        "u32"
+                    }
+                }
+                IntKind::B64 => {
+                    if signed {
+                        "i64"
+                    } else {
+                        "u64"
+                    }
+                }
+            },
+            PrimitiveType::Float => "f32",
+            PrimitiveType::Double => "f64",
+            PrimitiveType::PtrDiffT => "ptrdiff_t",
+            PrimitiveType::VaList => "va_list",
+        }
+    }
+
+    pub fn to_repr_c(&self, config: &Config) -> &'static str {
+        match *self {
+            PrimitiveType::Void => "void",
+            PrimitiveType::Bool => "bool",
+            PrimitiveType::Char => "char",
+            PrimitiveType::SChar => "signed char",
+            PrimitiveType::UChar => "unsigned char",
+            // NOTE: It'd be nice to use a char32_t, but:
+            //
+            //  * uchar.h is not present on mac (see #423).
+            //
+            //  * char32_t isn't required to be compatible with Rust's char, as
+            //    the C++ spec only requires it to be the same size as
+            //    uint_least32_t, which is _not_ guaranteed to be 4-bytes.
+            //
+            PrimitiveType::Char32 => "uint32_t",
+            PrimitiveType::Integer {
+                kind,
+                signed,
+                zeroable: _,
+            } => match kind {
+                IntKind::Short => {
+                    if signed {
+                        "short"
+                    } else {
+                        "unsigned short"
+                    }
+                }
+                IntKind::Int => {
+                    if signed {
+                        "int"
+                    } else {
+                        "unsigned int"
+                    }
+                }
+                IntKind::Long => {
+                    if signed {
+                        "long"
+                    } else {
+                        "unsigned long"
+                    }
+                }
+                IntKind::LongLong => {
+                    if signed {
+                        "long long"
+                    } else {
+                        "unsigned long long"
+                    }
+                }
+                IntKind::SizeT => {
+                    if signed {
+                        "ssize_t"
+                    } else {
+                        "size_t"
+                    }
+                }
+                IntKind::Size => {
+                    if config.usize_is_size_t {
+                        if signed {
+                            "ptrdiff_t"
+                        } else {
+                            "size_t"
+                        }
+                    } else if signed {
+                        "intptr_t"
+                    } else {
+                        "uintptr_t"
+                    }
+                }
+                IntKind::B8 => {
+                    if signed {
+                        "int8_t"
+                    } else {
+                        "uint8_t"
+                    }
+                }
+                IntKind::B16 => {
+                    if signed {
+                        "int16_t"
+                    } else {
+                        "uint16_t"
+                    }
+                }
+                IntKind::B32 => {
+                    if signed {
+                        "int32_t"
+                    } else {
+                        "uint32_t"
+                    }
+                }
+                IntKind::B64 => {
+                    if signed {
+                        "int64_t"
+                    } else {
+                        "uint64_t"
+                    }
+                }
+            },
+            PrimitiveType::Float => "float",
+            PrimitiveType::Double => "double",
+            PrimitiveType::PtrDiffT => "ptrdiff_t",
+            PrimitiveType::VaList => "va_list",
+        }
+    }
+
+    fn can_cmp_order(&self) -> bool {
+        !matches!(*self, PrimitiveType::Bool)
+    }
+
+    fn can_cmp_eq(&self) -> bool {
+        true
+    }
+}
+
+/// Constant expressions.
+///
+/// Used for the `U` part of `[T; U]` and const generics. We support a very
+/// limited vocabulary here: only identifiers and literals.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ConstExpr {
+    Name(String),
+    Value(String),
+}
+
+impl ConstExpr {
+    pub fn as_str(&self) -> &str {
+        match *self {
+            ConstExpr::Name(ref string) | ConstExpr::Value(ref string) => string,
+        }
+    }
+
+    pub fn rename_for_config(&mut self, config: &Config) {
+        if let ConstExpr::Name(ref mut name) = self {
+            config.export.rename(name);
+        }
+    }
+
+    pub fn load(expr: &syn::Expr) -> Result<Self, String> {
+        match *expr {
+            syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => {
+                let val = match *lit {
+                    syn::Lit::Bool(syn::LitBool { value, .. }) => value.to_string(),
+                    syn::Lit::Int(ref len) => len.base10_digits().to_string(),
+                    syn::Lit::Byte(ref byte) => u8::to_string(&byte.value()),
+                    syn::Lit::Char(ref ch) => u32::to_string(&ch.value().into()),
+                    _ => return Err(format!("can't handle const expression {:?}", lit)),
+                };
+                Ok(ConstExpr::Value(val))
+            }
+            syn::Expr::Path(ref path) => {
+                let generic_path = GenericPath::load(&path.path)?;
+                Ok(ConstExpr::Name(generic_path.export_name().to_owned()))
+            }
+            _ => Err(format!("can't handle const expression {:?}", expr)),
+        }
+    }
+
+    pub fn specialize(&self, mappings: &[(&Path, &GenericArgument)]) -> ConstExpr {
+        match *self {
+            ConstExpr::Name(ref name) => {
+                let path = Path::new(name);
+                for &(param, value) in mappings {
+                    if path == *param {
+                        match *value {
+                            GenericArgument::Type(Type::Path(ref path))
+                                if path.is_single_identifier() =>
+                            {
+                                // This happens when the generic argument is a path.
+                                return ConstExpr::Name(path.name().to_string());
+                            }
+                            GenericArgument::Const(ref expr) => {
+                                return expr.clone();
+                            }
+                            _ => {
+                                // unsupported argument type - really should be an error
+                            }
+                        }
+                    }
+                }
+            }
+            ConstExpr::Value(_) => {}
+        }
+        self.clone()
+    }
+}
+
+impl Source for ConstExpr {
+    fn write<F: Write>(&self, _config: &Config, out: &mut SourceWriter<F>) {
+        write!(out, "{}", self.as_str());
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum Type {
+    Ptr {
+        ty: Box<Type>,
+        is_const: bool,
+        is_nullable: bool,
+        // FIXME: This is a bit of a hack, this is only to get us to codegen
+        // `T&` / `const T&`, but we should probably pass that down as an option
+        // to code generation or something.
+        is_ref: bool,
+    },
+    Path(GenericPath),
+    Primitive(PrimitiveType),
+    Array(Box<Type>, ConstExpr),
+    FuncPtr {
+        ret: Box<Type>,
+        args: Vec<(Option<String>, Type)>,
+        is_nullable: bool,
+        never_return: bool,
+    },
+}
+
+impl Type {
+    pub fn const_ref_to(ty: &Self) -> Self {
+        Type::Ptr {
+            ty: Box::new(ty.clone()),
+            is_const: true,
+            is_nullable: false,
+            is_ref: true,
+        }
+    }
+
+    pub fn load_from_output(output: &syn::ReturnType) -> Result<(Type, bool), String> {
+        let mut never_return = false;
+        let ty = match output {
+            syn::ReturnType::Default => Type::Primitive(PrimitiveType::Void),
+            syn::ReturnType::Type(_, ref ty) => {
+                if let syn::Type::Never(_) = ty.as_ref() {
+                    never_return = true;
+                    Type::Primitive(PrimitiveType::Void)
+                } else {
+                    Type::load(ty)?.unwrap_or(Type::Primitive(PrimitiveType::Void))
+                }
+            }
+        };
+        Ok((ty, never_return))
+    }
+
+    pub fn load(ty: &syn::Type) -> Result<Option<Type>, String> {
+        let converted = match *ty {
+            syn::Type::Reference(ref reference) => {
+                let converted = Type::load(&reference.elem)?;
+
+                let converted = match converted {
+                    Some(converted) => converted,
+                    None => Type::Primitive(PrimitiveType::Void),
+                };
+
+                // TODO(emilio): we could make these use is_ref: true.
+                let is_const = reference.mutability.is_none();
+                Type::Ptr {
+                    ty: Box::new(converted),
+                    is_const,
+                    is_nullable: false,
+                    is_ref: false,
+                }
+            }
+            syn::Type::Ptr(ref pointer) => {
+                let converted = Type::load(&pointer.elem)?;
+
+                let converted = match converted {
+                    Some(converted) => converted,
+                    None => Type::Primitive(PrimitiveType::Void),
+                };
+
+                let is_const = pointer.mutability.is_none();
+                Type::Ptr {
+                    ty: Box::new(converted),
+                    is_const,
+                    is_nullable: true,
+                    is_ref: false,
+                }
+            }
+            syn::Type::Path(ref path) => {
+                let generic_path = GenericPath::load(&path.path)?;
+
+                if generic_path.name() == "PhantomData" || generic_path.name() == "PhantomPinned" {
+                    return Ok(None);
+                }
+
+                if let Some(prim) = PrimitiveType::maybe(generic_path.name()) {
+                    if !generic_path.generics().is_empty() {
+                        return Err("Primitive has generics.".to_owned());
+                    }
+                    Type::Primitive(prim)
+                } else {
+                    Type::Path(generic_path)
+                }
+            }
+            syn::Type::Array(syn::TypeArray {
+                ref elem, ref len, ..
+            }) => {
+                let converted = Type::load(elem)?;
+
+                let converted = match converted {
+                    Some(converted) => converted,
+                    None => return Err("Cannot have an array of zero sized types.".to_owned()),
+                };
+
+                let len = ConstExpr::load(len)?;
+                Type::Array(Box::new(converted), len)
+            }
+            syn::Type::BareFn(ref function) => {
+                let mut wildcard_counter = 0;
+                let args = function.inputs.iter().try_skip_map(|x| {
+                    Type::load(&x.ty).map(|opt_ty| {
+                        opt_ty.map(|ty| {
+                            (
+                                x.name.as_ref().map(|(ref ident, _)| {
+                                    if ident == "_" {
+                                        wildcard_counter += 1;
+                                        if wildcard_counter == 1 {
+                                            "_".to_owned()
+                                        } else {
+                                            format!("_{}", wildcard_counter - 1)
+                                        }
+                                    } else {
+                                        ident.unraw().to_string()
+                                    }
+                                }),
+                                ty,
+                            )
+                        })
+                    })
+                })?;
+                let (ret, never_return) = Type::load_from_output(&function.output)?;
+                Type::FuncPtr {
+                    ret: Box::new(ret),
+                    args,
+                    is_nullable: false,
+                    never_return,
+                }
+            }
+            syn::Type::Tuple(ref tuple) => {
+                if tuple.elems.is_empty() {
+                    return Ok(None);
+                }
+                return Err("Tuples are not supported types.".to_owned());
+            }
+            syn::Type::Verbatim(ref tokens) if tokens.to_string() == "..." => {
+                Type::Primitive(PrimitiveType::VaList)
+            }
+            _ => return Err(format!("Unsupported type: {:?}", ty)),
+        };
+
+        Ok(Some(converted))
+    }
+
+    pub fn is_ptr(&self) -> bool {
+        matches!(*self, Type::Ptr { .. } | Type::FuncPtr { .. })
+    }
+
+    pub fn is_primitive_or_ptr_primitive(&self) -> bool {
+        match *self {
+            Type::Primitive(..) => true,
+            Type::Ptr { ref ty, .. } => matches!(ty.as_ref(), Type::Primitive(..)),
+            _ => false,
+        }
+    }
+
+    pub fn make_zeroable(&self) -> Option<Self> {
+        let (kind, signed) = match *self {
+            Type::Primitive(PrimitiveType::Integer {
+                zeroable: false,
+                kind,
+                signed,
+            }) => (kind, signed),
+            _ => return None,
+        };
+
+        Some(Type::Primitive(PrimitiveType::Integer {
+            kind,
+            signed,
+            zeroable: true,
+        }))
+    }
+
+    pub fn make_nullable(&self) -> Option<Self> {
+        match *self {
+            Type::Ptr {
+                ref ty,
+                is_const,
+                is_ref,
+                is_nullable: false,
+            } => Some(Type::Ptr {
+                ty: ty.clone(),
+                is_const,
+                is_ref,
+                is_nullable: true,
+            }),
+            Type::FuncPtr {
+                ref ret,
+                ref args,
+                is_nullable: false,
+                never_return,
+            } => Some(Type::FuncPtr {
+                ret: ret.clone(),
+                args: args.clone(),
+                is_nullable: true,
+                never_return,
+            }),
+            _ => None,
+        }
+    }
+
+    fn nonzero_to_primitive(&self) -> Option<Self> {
+        let path = match *self {
+            Type::Path(ref p) => p,
+            _ => return None,
+        };
+
+        if !path.generics().is_empty() {
+            return None;
+        }
+
+        let name = path.name();
+        if !name.starts_with("NonZero") {
+            return None;
+        }
+
+        let (kind, signed) = match path.name() {
+            "NonZeroU8" => (IntKind::B8, false),
+            "NonZeroU16" => (IntKind::B16, false),
+            "NonZeroU32" => (IntKind::B32, false),
+            "NonZeroU64" => (IntKind::B64, false),
+            "NonZeroUSize" => (IntKind::Size, false),
+            "NonZeroI8" => (IntKind::B8, true),
+            "NonZeroI16" => (IntKind::B16, true),
+            "NonZeroI32" => (IntKind::B32, true),
+            "NonZeroI64" => (IntKind::B64, true),
+            "NonZeroISize" => (IntKind::Size, true),
+            _ => return None,
+        };
+
+        Some(Type::Primitive(PrimitiveType::Integer {
+            zeroable: false,
+            signed,
+            kind,
+        }))
+    }
+
+    fn simplified_type(&self, config: &Config) -> Option<Self> {
+        let path = match *self {
+            Type::Path(ref p) => p,
+            _ => return None,
+        };
+
+        if path.generics().is_empty() {
+            return self.nonzero_to_primitive();
+        }
+
+        if path.generics().len() != 1 {
+            return None;
+        }
+
+        let unsimplified_generic = match path.generics()[0] {
+            GenericArgument::Type(ref ty) => ty,
+            GenericArgument::Const(_) => return None,
+        };
+
+        let generic = match unsimplified_generic.simplified_type(config) {
+            Some(generic) => Cow::Owned(generic),
+            None => Cow::Borrowed(unsimplified_generic),
+        };
+        match path.name() {
+            "Option" => {
+                if let Some(nullable) = generic.make_nullable() {
+                    return Some(nullable);
+                }
+                if let Some(zeroable) = generic.make_zeroable() {
+                    return Some(zeroable);
+                }
+                None
+            }
+            "NonNull" => Some(Type::Ptr {
+                ty: Box::new(generic.into_owned()),
+                is_const: false,
+                is_nullable: false,
+                is_ref: false,
+            }),
+            "Box" if config.language != Language::Cxx => Some(Type::Ptr {
+                ty: Box::new(generic.into_owned()),
+                is_const: false,
+                is_nullable: false,
+                is_ref: false,
+            }),
+            "Cell" => Some(generic.into_owned()),
+            "ManuallyDrop" | "MaybeUninit" | "Pin" if config.language != Language::Cxx => {
+                Some(generic.into_owned())
+            }
+            _ => None,
+        }
+    }
+
+    pub fn simplify_standard_types(&mut self, config: &Config) {
+        self.visit_types(|ty| ty.simplify_standard_types(config));
+        if let Some(ty) = self.simplified_type(config) {
+            *self = ty;
+        }
+    }
+
+    pub fn replace_self_with(&mut self, self_ty: &Path) {
+        if let Type::Path(ref mut generic_path) = *self {
+            generic_path.replace_self_with(self_ty);
+        }
+        self.visit_types(|ty| ty.replace_self_with(self_ty))
+    }
+
+    fn visit_types(&mut self, mut visitor: impl FnMut(&mut Type)) {
+        match *self {
+            Type::Array(ref mut ty, ..) | Type::Ptr { ref mut ty, .. } => visitor(ty),
+            Type::Path(ref mut path) => {
+                for generic in path.generics_mut() {
+                    match *generic {
+                        GenericArgument::Type(ref mut ty) => visitor(ty),
+                        GenericArgument::Const(_) => {}
+                    }
+                }
+            }
+            Type::Primitive(..) => {}
+            Type::FuncPtr {
+                ref mut ret,
+                ref mut args,
+                ..
+            } => {
+                visitor(ret);
+                for arg in args {
+                    visitor(&mut arg.1)
+                }
+            }
+        }
+    }
+
+    pub fn get_root_path(&self) -> Option<Path> {
+        let mut current = self;
+        loop {
+            match *current {
+                Type::Ptr { ref ty, .. } => current = ty,
+                Type::Path(ref generic) => {
+                    return Some(generic.path().clone());
+                }
+                Type::Primitive(..) => {
+                    return None;
+                }
+                Type::Array(..) => {
+                    return None;
+                }
+                Type::FuncPtr { .. } => {
+                    return None;
+                }
+            };
+        }
+    }
+
+    pub fn specialize(&self, mappings: &[(&Path, &GenericArgument)]) -> Type {
+        match *self {
+            Type::Ptr {
+                ref ty,
+                is_const,
+                is_nullable,
+                is_ref,
+            } => Type::Ptr {
+                ty: Box::new(ty.specialize(mappings)),
+                is_const,
+                is_nullable,
+                is_ref,
+            },
+            Type::Path(ref generic_path) => {
+                for &(param, value) in mappings {
+                    if generic_path.path() == param {
+                        if let GenericArgument::Type(ref ty) = *value {
+                            return ty.clone();
+                        }
+                    }
+                }
+
+                let specialized = GenericPath::new(
+                    generic_path.path().clone(),
+                    generic_path
+                        .generics()
+                        .iter()
+                        .map(|x| x.specialize(mappings))
+                        .collect(),
+                );
+                Type::Path(specialized)
+            }
+            Type::Primitive(ref primitive) => Type::Primitive(primitive.clone()),
+            Type::Array(ref ty, ref constant) => Type::Array(
+                Box::new(ty.specialize(mappings)),
+                constant.specialize(mappings),
+            ),
+            Type::FuncPtr {
+                ref ret,
+                ref args,
+                is_nullable,
+                never_return,
+            } => Type::FuncPtr {
+                ret: Box::new(ret.specialize(mappings)),
+                args: args
+                    .iter()
+                    .cloned()
+                    .map(|(name, ty)| (name, ty.specialize(mappings)))
+                    .collect(),
+                is_nullable,
+                never_return,
+            },
+        }
+    }
+
+    pub fn add_dependencies_ignoring_generics(
+        &self,
+        generic_params: &GenericParams,
+        library: &Library,
+        out: &mut Dependencies,
+    ) {
+        match *self {
+            Type::Ptr { ref ty, .. } => {
+                ty.add_dependencies_ignoring_generics(generic_params, library, out);
+            }
+            Type::Path(ref generic) => {
+                for generic_value in generic.generics() {
+                    if let GenericArgument::Type(ref ty) = *generic_value {
+                        ty.add_dependencies_ignoring_generics(generic_params, library, out);
+                    }
+                }
+                let path = generic.path();
+                if !generic_params.iter().any(|param| param.name() == path) {
+                    if let Some(items) = library.get_items(path) {
+                        if !out.items.contains(path) {
+                            out.items.insert(path.clone());
+
+                            for item in &items {
+                                item.deref().add_dependencies(library, out);
+                            }
+                            for item in items {
+                                out.order.push(item);
+                            }
+                        }
+                    } else {
+                        warn!(
+                            "Can't find {}. This usually means that this type was incompatible or \
+                             not found.",
+                            path
+                        );
+                    }
+                }
+            }
+            Type::Primitive(_) => {}
+            Type::Array(ref ty, _) => {
+                ty.add_dependencies_ignoring_generics(generic_params, library, out);
+            }
+            Type::FuncPtr {
+                ref ret, ref args, ..
+            } => {
+                ret.add_dependencies_ignoring_generics(generic_params, library, out);
+                for (_, ref arg) in args {
+                    arg.add_dependencies_ignoring_generics(generic_params, library, out);
+                }
+            }
+        }
+    }
+
+    pub fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        self.add_dependencies_ignoring_generics(&GenericParams::default(), library, out)
+    }
+
+    pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+        match *self {
+            Type::Ptr { ref ty, .. } => {
+                ty.add_monomorphs(library, out);
+            }
+            Type::Path(ref generic) => {
+                if generic.generics().is_empty() || out.contains(generic) {
+                    return;
+                }
+                let path = generic.path();
+                if let Some(items) = library.get_items(path) {
+                    for item in items {
+                        item.deref()
+                            .instantiate_monomorph(generic.generics(), library, out);
+                    }
+                }
+            }
+            Type::Primitive(_) => {}
+            Type::Array(ref ty, _) => {
+                ty.add_monomorphs(library, out);
+            }
+            Type::FuncPtr {
+                ref ret, ref args, ..
+            } => {
+                ret.add_monomorphs(library, out);
+                for (_, ref arg) in args {
+                    arg.add_monomorphs(library, out);
+                }
+            }
+        }
+    }
+
+    pub fn rename_for_config(&mut self, config: &Config, generic_params: &GenericParams) {
+        match *self {
+            Type::Ptr { ref mut ty, .. } => {
+                ty.rename_for_config(config, generic_params);
+            }
+            Type::Path(ref mut ty) => {
+                ty.rename_for_config(config, generic_params);
+            }
+            Type::Primitive(_) => {}
+            Type::Array(ref mut ty, ref mut len) => {
+                ty.rename_for_config(config, generic_params);
+                len.rename_for_config(config);
+            }
+            Type::FuncPtr {
+                ref mut ret,
+                ref mut args,
+                ..
+            } => {
+                ret.rename_for_config(config, generic_params);
+                for (_, arg) in args {
+                    arg.rename_for_config(config, generic_params);
+                }
+            }
+        }
+    }
+
+    pub fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        match *self {
+            Type::Ptr { ref mut ty, .. } => {
+                ty.resolve_declaration_types(resolver);
+            }
+            Type::Path(ref mut generic_path) => {
+                generic_path.resolve_declaration_types(resolver);
+            }
+            Type::Primitive(_) => {}
+            Type::Array(ref mut ty, _) => {
+                ty.resolve_declaration_types(resolver);
+            }
+            Type::FuncPtr {
+                ref mut ret,
+                ref mut args,
+                ..
+            } => {
+                ret.resolve_declaration_types(resolver);
+                for (_, ref mut arg) in args {
+                    arg.resolve_declaration_types(resolver);
+                }
+            }
+        }
+    }
+
+    pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+        match *self {
+            Type::Ptr { ref mut ty, .. } => {
+                ty.mangle_paths(monomorphs);
+            }
+            Type::Path(ref mut generic_path) => {
+                if generic_path.generics().is_empty() {
+                    return;
+                }
+
+                if let Some(mangled_path) = monomorphs.mangle_path(generic_path) {
+                    *generic_path = GenericPath::new(mangled_path.clone(), vec![]);
+                } else {
+                    warn!(
+                        "Cannot find a mangling for generic path {:?}. This usually means that a \
+                         type referenced by this generic was incompatible or not found.",
+                        generic_path
+                    );
+                }
+            }
+            Type::Primitive(_) => {}
+            Type::Array(ref mut ty, _) => {
+                ty.mangle_paths(monomorphs);
+            }
+            Type::FuncPtr {
+                ref mut ret,
+                ref mut args,
+                ..
+            } => {
+                ret.mangle_paths(monomorphs);
+                for (_, ref mut arg) in args {
+                    arg.mangle_paths(monomorphs);
+                }
+            }
+        }
+    }
+
+    pub fn can_cmp_order(&self) -> bool {
+        match *self {
+            // FIXME: Shouldn't this look at ty.can_cmp_order() as well?
+            Type::Ptr { is_ref, .. } => !is_ref,
+            Type::Path(..) => true,
+            Type::Primitive(ref p) => p.can_cmp_order(),
+            Type::Array(..) => false,
+            Type::FuncPtr { .. } => false,
+        }
+    }
+
+    pub fn can_cmp_eq(&self) -> bool {
+        match *self {
+            Type::Ptr { ref ty, is_ref, .. } => !is_ref || ty.can_cmp_eq(),
+            Type::Path(..) => true,
+            Type::Primitive(ref p) => p.can_cmp_eq(),
+            Type::Array(..) => false,
+            Type::FuncPtr { .. } => true,
+        }
+    }
+}
+
+impl Source for String {
+    fn write<F: Write>(&self, _config: &Config, out: &mut SourceWriter<F>) {
+        write!(out, "{}", self);
+    }
+}
+
+impl Source for Type {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        cdecl::write_type(out, self, config);
+    }
+}
diff --git a/src/bindgen/ir/typedef.rs b/src/bindgen/ir/typedef.rs
new file mode 100644
index 0000000..626732e
--- /dev/null
+++ b/src/bindgen/ir/typedef.rs
@@ -0,0 +1,208 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::HashMap;
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::config::{Config, Language};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, ConditionWrite, Documentation, Field, GenericArgument, GenericParams, Item,
+    ItemContainer, Path, ToCondition, Type,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::mangle;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::writer::{Source, SourceWriter};
+
+/// A type alias that is represented as a C typedef
+#[derive(Debug, Clone)]
+pub struct Typedef {
+    pub path: Path,
+    pub export_name: String,
+    pub generic_params: GenericParams,
+    pub aliased: Type,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+}
+
+impl Typedef {
+    pub fn load(item: &syn::ItemType, mod_cfg: Option<&Cfg>) -> Result<Typedef, String> {
+        if let Some(x) = Type::load(&item.ty)? {
+            let path = Path::new(item.ident.unraw().to_string());
+            Ok(Typedef::new(
+                path,
+                GenericParams::load(&item.generics)?,
+                x,
+                Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
+                AnnotationSet::load(&item.attrs)?,
+                Documentation::load(&item.attrs),
+            ))
+        } else {
+            Err("Cannot have a typedef of a zero sized type.".to_owned())
+        }
+    }
+
+    pub fn new(
+        path: Path,
+        generic_params: GenericParams,
+        aliased: Type,
+        cfg: Option<Cfg>,
+        annotations: AnnotationSet,
+        documentation: Documentation,
+    ) -> Self {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            generic_params,
+            aliased,
+            cfg,
+            annotations,
+            documentation,
+        }
+    }
+
+    pub fn simplify_standard_types(&mut self, config: &Config) {
+        self.aliased.simplify_standard_types(config);
+    }
+
+    pub fn transfer_annotations(&mut self, out: &mut HashMap<Path, AnnotationSet>) {
+        if self.annotations.is_empty() {
+            return;
+        }
+
+        if let Some(alias_path) = self.aliased.get_root_path() {
+            if out.contains_key(&alias_path) {
+                warn!(
+                    "Multiple typedef's with annotations for {}. Ignoring annotations from {}.",
+                    alias_path, self.path
+                );
+                return;
+            }
+
+            out.insert(alias_path, self.annotations.clone());
+            self.annotations = AnnotationSet::new();
+        }
+    }
+
+    pub fn is_generic(&self) -> bool {
+        self.generic_params.len() > 0
+    }
+
+    pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+        // Generic structs can instantiate monomorphs only once they've been
+        // instantiated. See `instantiate_monomorph` for more details.
+        if self.is_generic() {
+            return;
+        }
+
+        self.aliased.add_monomorphs(library, out);
+    }
+
+    pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+        self.aliased.mangle_paths(monomorphs);
+    }
+}
+
+impl Item for Typedef {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    fn cfg(&self) -> Option<&Cfg> {
+        self.cfg.as_ref()
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::Typedef(self.clone())
+    }
+
+    fn rename_for_config(&mut self, config: &Config) {
+        config.export.rename(&mut self.export_name);
+        self.aliased.rename_for_config(config, &self.generic_params);
+    }
+
+    fn collect_declaration_types(&self, resolver: &mut DeclarationTypeResolver) {
+        resolver.add_none(&self.path);
+    }
+
+    fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        self.aliased.resolve_declaration_types(resolver);
+    }
+
+    fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        self.aliased
+            .add_dependencies_ignoring_generics(&self.generic_params, library, out);
+    }
+
+    fn instantiate_monomorph(
+        &self,
+        generic_values: &[GenericArgument],
+        library: &Library,
+        out: &mut Monomorphs,
+    ) {
+        let mappings = self.generic_params.call(self.path.name(), generic_values);
+
+        let mangled_path = mangle::mangle_path(
+            &self.path,
+            generic_values,
+            &library.get_config().export.mangle,
+        );
+
+        let monomorph = Typedef::new(
+            mangled_path,
+            GenericParams::default(),
+            self.aliased.specialize(&mappings),
+            self.cfg.clone(),
+            self.annotations.clone(),
+            self.documentation.clone(),
+        );
+
+        out.insert_typedef(library, self, monomorph, generic_values.to_owned());
+    }
+}
+
+impl Source for Typedef {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        let condition = self.cfg.to_condition(config);
+        condition.write_before(config, out);
+
+        self.documentation.write(config, out);
+
+        self.generic_params.write(config, out);
+
+        match config.language {
+            Language::Cxx => {
+                write!(out, "using {} = ", self.export_name());
+                self.aliased.write(config, out);
+            }
+            Language::C | Language::Cython => {
+                write!(out, "{} ", config.language.typedef());
+                Field::from_name_and_type(self.export_name().to_owned(), self.aliased.clone())
+                    .write(config, out);
+            }
+        }
+
+        out.write(";");
+
+        condition.write_after(config, out);
+    }
+}
diff --git a/src/bindgen/ir/union.rs b/src/bindgen/ir/union.rs
new file mode 100644
index 0000000..07bd16c
--- /dev/null
+++ b/src/bindgen/ir/union.rs
@@ -0,0 +1,336 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::config::{Config, Language, LayoutConfig};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, ConditionWrite, Documentation, Field, GenericArgument, GenericParams, Item,
+    ItemContainer, Path, Repr, ReprAlign, ReprStyle, ToCondition,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::mangle;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::rename::{IdentifierType, RenameRule};
+use crate::bindgen::utilities::IterHelpers;
+use crate::bindgen::writer::{ListType, Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct Union {
+    pub path: Path,
+    pub export_name: String,
+    pub generic_params: GenericParams,
+    pub fields: Vec<Field>,
+    pub tuple_union: bool,
+    pub alignment: Option<ReprAlign>,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+}
+
+impl Union {
+    pub fn load(
+        layout_config: &LayoutConfig,
+        item: &syn::ItemUnion,
+        mod_cfg: Option<&Cfg>,
+    ) -> Result<Union, String> {
+        let repr = Repr::load(&item.attrs)?;
+        if repr.style != ReprStyle::C {
+            return Err("Union is not marked #[repr(C)].".to_owned());
+        }
+
+        // Ensure we can safely represent the union given the configuration.
+        if let Some(align) = repr.align {
+            layout_config.ensure_safe_to_represent(&align)?;
+        }
+
+        let path = Path::new(item.ident.unraw().to_string());
+
+        let (fields, tuple_union) = {
+            let out = item
+                .fields
+                .named
+                .iter()
+                .try_skip_map(|field| Field::load(field, &path))?;
+            (out, false)
+        };
+
+        Ok(Union::new(
+            path,
+            GenericParams::load(&item.generics)?,
+            fields,
+            repr.align,
+            tuple_union,
+            Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
+            AnnotationSet::load(&item.attrs)?,
+            Documentation::load(&item.attrs),
+        ))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        path: Path,
+        generic_params: GenericParams,
+        fields: Vec<Field>,
+        alignment: Option<ReprAlign>,
+        tuple_union: bool,
+        cfg: Option<Cfg>,
+        annotations: AnnotationSet,
+        documentation: Documentation,
+    ) -> Self {
+        let export_name = path.name().to_owned();
+        Self {
+            path,
+            export_name,
+            generic_params,
+            fields,
+            tuple_union,
+            alignment,
+            cfg,
+            annotations,
+            documentation,
+        }
+    }
+
+    pub fn simplify_standard_types(&mut self, config: &Config) {
+        for field in &mut self.fields {
+            field.ty.simplify_standard_types(config);
+        }
+    }
+
+    pub fn is_generic(&self) -> bool {
+        self.generic_params.len() > 0
+    }
+
+    pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+        // Generic unions can instantiate monomorphs only once they've been
+        // instantiated. See `instantiate_monomorph` for more details.
+        if self.is_generic() {
+            return;
+        }
+
+        for field in &self.fields {
+            field.ty.add_monomorphs(library, out);
+        }
+    }
+
+    pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+        for field in &mut self.fields {
+            field.ty.mangle_paths(monomorphs);
+        }
+    }
+}
+
+impl Item for Union {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn export_name(&self) -> &str {
+        &self.export_name
+    }
+
+    fn cfg(&self) -> Option<&Cfg> {
+        self.cfg.as_ref()
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::Union(self.clone())
+    }
+
+    fn collect_declaration_types(&self, resolver: &mut DeclarationTypeResolver) {
+        resolver.add_union(&self.path);
+    }
+
+    fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+        for field in &mut self.fields {
+            field.ty.resolve_declaration_types(resolver);
+        }
+    }
+
+    fn rename_for_config(&mut self, config: &Config) {
+        config.export.rename(&mut self.export_name);
+        for field in &mut self.fields {
+            field.ty.rename_for_config(config, &self.generic_params);
+        }
+
+        let rules = self
+            .annotations
+            .parse_atom::<RenameRule>("rename-all")
+            .unwrap_or(config.structure.rename_fields);
+
+        if let Some(o) = self.annotations.list("field-names") {
+            let mut overriden_fields = Vec::new();
+
+            for (i, field) in self.fields.iter().enumerate() {
+                if i >= o.len() {
+                    overriden_fields.push(field.clone());
+                } else {
+                    overriden_fields.push(Field {
+                        name: o[i].clone(),
+                        ty: field.ty.clone(),
+                        cfg: field.cfg.clone(),
+                        annotations: field.annotations.clone(),
+                        documentation: field.documentation.clone(),
+                    });
+                }
+            }
+
+            self.fields = overriden_fields;
+        } else if let Some(r) = rules.not_none() {
+            self.fields = self
+                .fields
+                .iter()
+                .map(|field| Field {
+                    name: r
+                        .apply(&field.name, IdentifierType::StructMember)
+                        .into_owned(),
+                    ty: field.ty.clone(),
+                    cfg: field.cfg.clone(),
+                    annotations: field.annotations.clone(),
+                    documentation: field.documentation.clone(),
+                })
+                .collect();
+        } else if self.tuple_union {
+            // If we don't have any rules for a tuple union, prefix them with
+            // an underscore so it still compiles
+            for field in &mut self.fields {
+                field.name.insert(0, '_');
+            }
+        }
+    }
+
+    fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+        for field in &self.fields {
+            field
+                .ty
+                .add_dependencies_ignoring_generics(&self.generic_params, library, out);
+        }
+    }
+
+    fn instantiate_monomorph(
+        &self,
+        generic_values: &[GenericArgument],
+        library: &Library,
+        out: &mut Monomorphs,
+    ) {
+        let mappings = self.generic_params.call(self.path.name(), generic_values);
+
+        let mangled_path = mangle::mangle_path(
+            &self.path,
+            generic_values,
+            &library.get_config().export.mangle,
+        );
+
+        let monomorph = Union::new(
+            mangled_path,
+            GenericParams::default(),
+            self.fields
+                .iter()
+                .map(|field| Field {
+                    name: field.name.clone(),
+                    ty: field.ty.specialize(&mappings),
+                    cfg: field.cfg.clone(),
+                    annotations: field.annotations.clone(),
+                    documentation: field.documentation.clone(),
+                })
+                .collect(),
+            self.alignment,
+            self.tuple_union,
+            self.cfg.clone(),
+            self.annotations.clone(),
+            self.documentation.clone(),
+        );
+
+        out.insert_union(library, self, monomorph, generic_values.to_owned());
+    }
+}
+
+impl Source for Union {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        let condition = self.cfg.to_condition(config);
+        condition.write_before(config, out);
+
+        self.documentation.write(config, out);
+
+        self.generic_params.write(config, out);
+
+        // The following results in
+        // C++ or C with Tag as style:
+        //   union Name {
+        // C with Type only style:
+        //   typedef union {
+        // C with Both as style:
+        //   typedef union Name {
+        match config.language {
+            Language::C if config.style.generate_typedef() => out.write("typedef "),
+            Language::C | Language::Cxx => {}
+            Language::Cython => out.write(config.style.cython_def()),
+        }
+
+        out.write("union");
+
+        // Cython supports `packed` on structs (see comments there), but not on unions.
+        if config.language != Language::Cython {
+            if let Some(align) = self.alignment {
+                match align {
+                    ReprAlign::Packed => {
+                        if let Some(ref anno) = config.layout.packed {
+                            write!(out, " {}", anno);
+                        }
+                    }
+                    ReprAlign::Align(n) => {
+                        if let Some(ref anno) = config.layout.aligned_n {
+                            write!(out, " {}({})", anno, n);
+                        }
+                    }
+                }
+            }
+        }
+
+        if config.language != Language::C || config.style.generate_tag() {
+            write!(out, " {}", self.export_name);
+        }
+
+        out.open_brace();
+
+        // Emit the pre_body section, if relevant
+        if let Some(body) = config.export.pre_body(&self.path) {
+            out.write_raw_block(body);
+            out.new_line();
+        }
+
+        out.write_vertical_source_list(&self.fields, ListType::Cap(";"));
+        if config.language == Language::Cython && self.fields.is_empty() {
+            out.write("pass");
+        }
+
+        // Emit the post_body section, if relevant
+        if let Some(body) = config.export.post_body(&self.path) {
+            out.new_line();
+            out.write_raw_block(body);
+        }
+
+        if config.language == Language::C && config.style.generate_typedef() {
+            out.close_brace(false);
+            write!(out, " {};", self.export_name);
+        } else {
+            out.close_brace(true);
+        }
+
+        condition.write_after(config, out);
+    }
+}
diff --git a/src/bindgen/library.rs b/src/bindgen/library.rs
new file mode 100644
index 0000000..cb4cfbd
--- /dev/null
+++ b/src/bindgen/library.rs
@@ -0,0 +1,446 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use crate::bindgen::bindings::Bindings;
+use crate::bindgen::config::{Config, Language, SortKey};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::error::Error;
+use crate::bindgen::ir::{Constant, Enum, Function, Item, ItemContainer, ItemMap};
+use crate::bindgen::ir::{OpaqueItem, Path, Static, Struct, Typedef, Union};
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::ItemType;
+
+#[derive(Debug, Clone)]
+pub struct Library {
+    config: Config,
+    constants: ItemMap<Constant>,
+    globals: ItemMap<Static>,
+    enums: ItemMap<Enum>,
+    structs: ItemMap<Struct>,
+    unions: ItemMap<Union>,
+    opaque_items: ItemMap<OpaqueItem>,
+    typedefs: ItemMap<Typedef>,
+    functions: Vec<Function>,
+    source_files: Vec<PathBuf>,
+}
+
+impl Library {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        config: Config,
+        constants: ItemMap<Constant>,
+        globals: ItemMap<Static>,
+        enums: ItemMap<Enum>,
+        structs: ItemMap<Struct>,
+        unions: ItemMap<Union>,
+        opaque_items: ItemMap<OpaqueItem>,
+        typedefs: ItemMap<Typedef>,
+        functions: Vec<Function>,
+        source_files: Vec<PathBuf>,
+    ) -> Library {
+        Library {
+            config,
+            constants,
+            globals,
+            enums,
+            structs,
+            unions,
+            opaque_items,
+            typedefs,
+            functions,
+            source_files,
+        }
+    }
+
+    pub fn generate(mut self) -> Result<Bindings, Error> {
+        self.transfer_annotations();
+        self.simplify_standard_types();
+
+        match self.config.function.sort_by.unwrap_or(self.config.sort_by) {
+            SortKey::Name => self.functions.sort_by(|x, y| x.path.cmp(&y.path)),
+            SortKey::None => { /* keep input order */ }
+        }
+
+        if self.config.language != Language::Cxx {
+            self.instantiate_monomorphs();
+        }
+        self.remove_excluded();
+        if self.config.language == Language::C {
+            self.resolve_declaration_types();
+        }
+
+        self.rename_items();
+
+        let mut dependencies = Dependencies::new();
+
+        for function in &self.functions {
+            function.add_dependencies(&self, &mut dependencies);
+        }
+        self.globals.for_all_items(|global| {
+            global.add_dependencies(&self, &mut dependencies);
+        });
+        self.constants.for_all_items(|constant| {
+            constant.add_dependencies(&self, &mut dependencies);
+        });
+        for name in &self.config.export.include {
+            let path = Path::new(name.clone());
+            if let Some(items) = self.get_items(&path) {
+                if dependencies.items.insert(path) {
+                    for item in &items {
+                        item.deref().add_dependencies(&self, &mut dependencies);
+                    }
+                    for item in items {
+                        dependencies.order.push(item);
+                    }
+                }
+            }
+        }
+
+        dependencies.sort();
+
+        let items = dependencies.order;
+        let constants = if self.config.export.should_generate(ItemType::Constants) {
+            let mut constants = self.constants.to_vec();
+            match self.config.constant.sort_by.unwrap_or(self.config.sort_by) {
+                SortKey::Name => constants.sort_by(|x, y| x.path.cmp(&y.path)),
+                SortKey::None => { /* keep input order */ }
+            }
+            constants
+        } else {
+            vec![]
+        };
+
+        let globals = if self.config.export.should_generate(ItemType::Globals) {
+            let mut globals = self.globals.to_vec();
+            match self.config.constant.sort_by.unwrap_or(self.config.sort_by) {
+                SortKey::Name => globals.sort_by(|x, y| x.path.cmp(&y.path)),
+                SortKey::None => { /* keep input order */ }
+            }
+            globals
+        } else {
+            vec![]
+        };
+        let functions = if self.config.export.should_generate(ItemType::Functions) {
+            self.functions
+        } else {
+            vec![]
+        };
+
+        Ok(Bindings::new(
+            self.config,
+            self.structs,
+            self.typedefs,
+            constants,
+            globals,
+            items,
+            functions,
+            self.source_files,
+            false,
+        ))
+    }
+
+    pub fn get_items(&self, p: &Path) -> Option<Vec<ItemContainer>> {
+        macro_rules! find {
+            ($field:ident, $kind:ident) => {
+                if self.config.export.should_generate(ItemType::$kind) {
+                    if let Some(x) = self.$field.get_items(p) {
+                        return Some(x);
+                    }
+                }
+            };
+        }
+
+        find!(enums, Enums);
+        find!(structs, Structs);
+        find!(unions, Unions);
+        find!(opaque_items, OpaqueItems);
+        find!(typedefs, Typedefs);
+
+        None
+    }
+
+    pub fn get_config(&self) -> &Config {
+        &self.config
+    }
+
+    fn remove_excluded(&mut self) {
+        let config = &self.config;
+        // FIXME: interpret `config.export.exclude` as `Path`s.
+        self.functions
+            .retain(|x| !config.export.exclude.iter().any(|y| y == x.path().name()));
+        self.enums
+            .filter(|x| config.export.exclude.iter().any(|y| y == x.path().name()));
+        self.structs
+            .filter(|x| config.export.exclude.iter().any(|y| y == x.path().name()));
+        self.unions
+            .filter(|x| config.export.exclude.iter().any(|y| y == x.path().name()));
+        self.opaque_items
+            .filter(|x| config.export.exclude.iter().any(|y| y == x.path().name()));
+        self.typedefs
+            .filter(|x| config.export.exclude.iter().any(|y| y == x.path().name()));
+        self.globals
+            .filter(|x| config.export.exclude.iter().any(|y| y == x.path().name()));
+        self.constants
+            .filter(|x| config.export.exclude.iter().any(|y| y == x.path().name()));
+    }
+
+    fn transfer_annotations(&mut self) {
+        let mut annotations = HashMap::new();
+
+        self.typedefs.for_all_items_mut(|x| {
+            x.transfer_annotations(&mut annotations);
+        });
+
+        for (alias_path, annotations) in annotations {
+            // TODO
+            let mut transferred = false;
+
+            self.enums.for_items_mut(&alias_path, |x| {
+                if x.annotations().is_empty() {
+                    *x.annotations_mut() = annotations.clone();
+                    transferred = true;
+                } else {
+                    warn!(
+                        "Can't transfer annotations from typedef to alias ({}) \
+                         that already has annotations.",
+                        alias_path
+                    );
+                }
+            });
+            if transferred {
+                continue;
+            }
+            self.structs.for_items_mut(&alias_path, |x| {
+                if x.annotations().is_empty() {
+                    *x.annotations_mut() = annotations.clone();
+                    transferred = true;
+                } else {
+                    warn!(
+                        "Can't transfer annotations from typedef to alias ({}) \
+                         that already has annotations.",
+                        alias_path
+                    );
+                }
+            });
+            if transferred {
+                continue;
+            }
+            self.unions.for_items_mut(&alias_path, |x| {
+                if x.annotations().is_empty() {
+                    *x.annotations_mut() = annotations.clone();
+                    transferred = true;
+                } else {
+                    warn!(
+                        "Can't transfer annotations from typedef to alias ({}) \
+                         that already has annotations.",
+                        alias_path
+                    );
+                }
+            });
+            if transferred {
+                continue;
+            }
+            self.opaque_items.for_items_mut(&alias_path, |x| {
+                if x.annotations().is_empty() {
+                    *x.annotations_mut() = annotations.clone();
+                    transferred = true;
+                } else {
+                    warn!(
+                        "Can't transfer annotations from typedef to alias ({}) \
+                         that already has annotations.",
+                        alias_path
+                    );
+                }
+            });
+            if transferred {
+                continue;
+            }
+            self.typedefs.for_items_mut(&alias_path, |x| {
+                if x.annotations().is_empty() {
+                    *x.annotations_mut() = annotations.clone();
+                    transferred = true;
+                } else {
+                    warn!(
+                        "Can't transfer annotations from typedef to alias ({}) \
+                         that already has annotations.",
+                        alias_path
+                    );
+                }
+            });
+            if transferred {
+                continue;
+            }
+        }
+    }
+
+    fn rename_items(&mut self) {
+        let config = &self.config;
+
+        self.globals
+            .for_all_items_mut(|x| x.rename_for_config(config));
+        self.globals.rebuild();
+
+        self.constants
+            .for_all_items_mut(|x| x.rename_for_config(config));
+        self.constants.rebuild();
+
+        self.structs
+            .for_all_items_mut(|x| x.rename_for_config(config));
+        self.structs.rebuild();
+
+        self.unions
+            .for_all_items_mut(|x| x.rename_for_config(config));
+        self.unions.rebuild();
+
+        self.enums
+            .for_all_items_mut(|x| x.rename_for_config(config));
+        self.enums.rebuild();
+
+        self.opaque_items
+            .for_all_items_mut(|x| x.rename_for_config(config));
+        self.opaque_items.rebuild();
+
+        self.typedefs
+            .for_all_items_mut(|x| x.rename_for_config(config));
+        self.typedefs.rebuild();
+
+        for item in &mut self.functions {
+            item.rename_for_config(&self.config);
+        }
+    }
+
+    fn resolve_declaration_types(&mut self) {
+        if !self.config.style.generate_tag() {
+            return;
+        }
+
+        let mut resolver = DeclarationTypeResolver::default();
+
+        self.structs.for_all_items(|x| {
+            x.collect_declaration_types(&mut resolver);
+        });
+
+        self.enums.for_all_items(|x| {
+            x.collect_declaration_types(&mut resolver);
+        });
+
+        self.unions.for_all_items(|x| {
+            x.collect_declaration_types(&mut resolver);
+        });
+
+        self.typedefs.for_all_items(|x| {
+            x.collect_declaration_types(&mut resolver);
+        });
+
+        // NOTE: Intentionally last, so that in case there's an opaque type
+        // which is conflicting with a non-opaque one, the later wins.
+        self.opaque_items.for_all_items(|x| {
+            x.collect_declaration_types(&mut resolver);
+        });
+
+        self.enums
+            .for_all_items_mut(|x| x.resolve_declaration_types(&resolver));
+
+        self.structs
+            .for_all_items_mut(|x| x.resolve_declaration_types(&resolver));
+
+        self.unions
+            .for_all_items_mut(|x| x.resolve_declaration_types(&resolver));
+
+        self.typedefs
+            .for_all_items_mut(|x| x.resolve_declaration_types(&resolver));
+
+        self.globals
+            .for_all_items_mut(|x| x.resolve_declaration_types(&resolver));
+
+        for item in &mut self.functions {
+            item.resolve_declaration_types(&resolver);
+        }
+    }
+
+    fn simplify_standard_types(&mut self) {
+        let config = &self.config;
+
+        self.structs.for_all_items_mut(|x| {
+            x.simplify_standard_types(config);
+        });
+        self.enums.for_all_items_mut(|x| {
+            x.simplify_standard_types(config);
+        });
+        self.unions.for_all_items_mut(|x| {
+            x.simplify_standard_types(config);
+        });
+        self.globals.for_all_items_mut(|x| {
+            x.simplify_standard_types(config);
+        });
+        self.typedefs.for_all_items_mut(|x| {
+            x.simplify_standard_types(config);
+        });
+        for x in &mut self.functions {
+            x.simplify_standard_types(config);
+        }
+    }
+
+    fn instantiate_monomorphs(&mut self) {
+        // Collect a list of monomorphs
+        let mut monomorphs = Monomorphs::default();
+
+        self.structs.for_all_items(|x| {
+            x.add_monomorphs(self, &mut monomorphs);
+        });
+        self.unions.for_all_items(|x| {
+            x.add_monomorphs(self, &mut monomorphs);
+        });
+        self.enums.for_all_items(|x| {
+            x.add_monomorphs(self, &mut monomorphs);
+        });
+        self.typedefs.for_all_items(|x| {
+            x.add_monomorphs(self, &mut monomorphs);
+        });
+        for x in &self.functions {
+            x.add_monomorphs(self, &mut monomorphs);
+        }
+
+        // Insert the monomorphs into self
+        for monomorph in monomorphs.drain_structs() {
+            self.structs.try_insert(monomorph);
+        }
+        for monomorph in monomorphs.drain_unions() {
+            self.unions.try_insert(monomorph);
+        }
+        for monomorph in monomorphs.drain_opaques() {
+            self.opaque_items.try_insert(monomorph);
+        }
+        for monomorph in monomorphs.drain_typedefs() {
+            self.typedefs.try_insert(monomorph);
+        }
+        for monomorph in monomorphs.drain_enums() {
+            self.enums.try_insert(monomorph);
+        }
+
+        // Remove structs and opaque items that are generic
+        self.opaque_items.filter(|x| x.generic_params.len() > 0);
+        self.structs.filter(|x| x.generic_params.len() > 0);
+        self.unions.filter(|x| x.generic_params.len() > 0);
+        self.enums.filter(|x| x.generic_params.len() > 0);
+        self.typedefs.filter(|x| x.generic_params.len() > 0);
+
+        // Mangle the paths that remain
+        self.unions
+            .for_all_items_mut(|x| x.mangle_paths(&monomorphs));
+        self.structs
+            .for_all_items_mut(|x| x.mangle_paths(&monomorphs));
+        self.enums
+            .for_all_items_mut(|x| x.mangle_paths(&monomorphs));
+        self.typedefs
+            .for_all_items_mut(|x| x.mangle_paths(&monomorphs));
+        for x in &mut self.functions {
+            x.mangle_paths(&monomorphs);
+        }
+    }
+}
diff --git a/src/bindgen/mangle.rs b/src/bindgen/mangle.rs
new file mode 100644
index 0000000..c8769f8
--- /dev/null
+++ b/src/bindgen/mangle.rs
@@ -0,0 +1,348 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::bindgen::config::MangleConfig;
+use crate::bindgen::ir::{ConstExpr, GenericArgument, GenericPath, Path, Type};
+use crate::bindgen::rename::IdentifierType;
+
+pub fn mangle_path(path: &Path, generic_values: &[GenericArgument], config: &MangleConfig) -> Path {
+    Path::new(mangle_name(path.name(), generic_values, config))
+}
+
+pub fn mangle_name(
+    name: &str,
+    generic_values: &[GenericArgument],
+    config: &MangleConfig,
+) -> String {
+    Mangler::new(name, generic_values, /* last = */ true, config).mangle()
+}
+
+enum Separator {
+    OpeningAngleBracket = 1,
+    Comma,
+    ClosingAngleBracket,
+    BeginMutPtr,
+    BeginConstPtr,
+    BeginFn,
+    BetweenFnArg,
+    EndFn,
+}
+
+struct Mangler<'a> {
+    input: &'a str,
+    generic_values: &'a [GenericArgument],
+    output: String,
+    last: bool,
+    config: &'a MangleConfig,
+}
+
+impl<'a> Mangler<'a> {
+    fn new(
+        input: &'a str,
+        generic_values: &'a [GenericArgument],
+        last: bool,
+        config: &'a MangleConfig,
+    ) -> Self {
+        Self {
+            input,
+            generic_values,
+            output: String::new(),
+            last,
+            config,
+        }
+    }
+
+    fn mangle(mut self) -> String {
+        self.mangle_internal();
+        self.output
+    }
+
+    fn push(&mut self, id: Separator) {
+        let count = id as usize;
+        let separator = if self.config.remove_underscores {
+            ""
+        } else {
+            "_"
+        };
+        self.output.extend(std::iter::repeat(separator).take(count));
+    }
+
+    fn append_mangled_argument(&mut self, arg: &GenericArgument, last: bool) {
+        match *arg {
+            GenericArgument::Type(ref ty) => self.append_mangled_type(ty, last),
+            GenericArgument::Const(ConstExpr::Name(ref name)) => {
+                // This must behave the same as a GenericArgument::Type,
+                // because const arguments are commonly represented as Types;
+                // see the comment on `enum GenericArgument`.
+                let fake_ty = Type::Path(GenericPath::new(Path::new(name), vec![]));
+                self.append_mangled_type(&fake_ty, last);
+            }
+            GenericArgument::Const(ConstExpr::Value(ref val)) => self.output.push_str(val),
+        }
+    }
+
+    fn append_mangled_type(&mut self, ty: &Type, last: bool) {
+        match *ty {
+            Type::Path(ref generic) => {
+                let sub_path =
+                    Mangler::new(generic.export_name(), generic.generics(), last, self.config)
+                        .mangle();
+
+                self.output.push_str(
+                    &self
+                        .config
+                        .rename_types
+                        .apply(&sub_path, IdentifierType::Type),
+                );
+            }
+            Type::Primitive(ref primitive) => {
+                self.output.push_str(
+                    &self
+                        .config
+                        .rename_types
+                        .apply(primitive.to_repr_rust(), IdentifierType::Type),
+                );
+            }
+            Type::Ptr {
+                ref ty, is_const, ..
+            } => {
+                self.push(if is_const {
+                    Separator::BeginConstPtr
+                } else {
+                    Separator::BeginMutPtr
+                });
+                self.append_mangled_type(ty, last);
+            }
+            Type::FuncPtr {
+                ref ret, ref args, ..
+            } => {
+                self.push(Separator::BeginFn);
+                self.append_mangled_type(ret, args.is_empty());
+                for (i, arg) in args.iter().enumerate() {
+                    self.push(Separator::BetweenFnArg);
+                    let last = last && i == args.len() - 1;
+                    self.append_mangled_type(&arg.1, last);
+                }
+                if !self.last {
+                    self.push(Separator::EndFn);
+                }
+            }
+            Type::Array(..) => {
+                unimplemented!(
+                    "Unable to mangle generic parameter {:?} for '{}'",
+                    ty,
+                    self.input
+                );
+            }
+        }
+    }
+
+    fn mangle_internal(&mut self) {
+        debug_assert!(self.output.is_empty());
+        self.output = self.input.to_owned();
+        if self.generic_values.is_empty() {
+            return;
+        }
+
+        self.push(Separator::OpeningAngleBracket);
+        for (i, arg) in self.generic_values.iter().enumerate() {
+            if i != 0 {
+                self.push(Separator::Comma);
+            }
+            let last = self.last && i == self.generic_values.len() - 1;
+            self.append_mangled_argument(arg, last);
+        }
+
+        // Skip writing the trailing '>' mangling when possible
+        if !self.last {
+            self.push(Separator::ClosingAngleBracket)
+        }
+    }
+}
+
+#[test]
+fn generics() {
+    use crate::bindgen::ir::{GenericPath, PrimitiveType};
+    use crate::bindgen::rename::RenameRule::{self, PascalCase};
+
+    fn float() -> GenericArgument {
+        GenericArgument::Type(Type::Primitive(PrimitiveType::Float))
+    }
+
+    fn c_char() -> GenericArgument {
+        GenericArgument::Type(Type::Primitive(PrimitiveType::Char))
+    }
+
+    fn path(path: &str) -> GenericArgument {
+        generic_path(path, &[])
+    }
+
+    fn generic_path(path: &str, arguments: &[GenericArgument]) -> GenericArgument {
+        let path = Path::new(path);
+        let generic_path = GenericPath::new(path, arguments.to_owned());
+        GenericArgument::Type(Type::Path(generic_path))
+    }
+
+    // Foo<f32> => Foo_f32
+    assert_eq!(
+        mangle_path(&Path::new("Foo"), &[float()], &MangleConfig::default()),
+        Path::new("Foo_f32")
+    );
+
+    // Foo<Bar<f32>> => Foo_Bar_f32
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[generic_path("Bar", &[float()])],
+            &MangleConfig::default(),
+        ),
+        Path::new("Foo_Bar_f32")
+    );
+
+    // Foo<Bar> => Foo_Bar
+    assert_eq!(
+        mangle_path(&Path::new("Foo"), &[path("Bar")], &MangleConfig::default()),
+        Path::new("Foo_Bar")
+    );
+
+    // Foo<Bar> => FooBar
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[path("Bar")],
+            &MangleConfig {
+                remove_underscores: true,
+                rename_types: RenameRule::None,
+            }
+        ),
+        Path::new("FooBar")
+    );
+
+    // Foo<Bar<f32>> => FooBarF32
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[generic_path("Bar", &[float()])],
+            &MangleConfig {
+                remove_underscores: true,
+                rename_types: PascalCase,
+            },
+        ),
+        Path::new("FooBarF32")
+    );
+
+    // Foo<Bar<c_char>> => FooBarCChar
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[generic_path("Bar", &[c_char()])],
+            &MangleConfig {
+                remove_underscores: true,
+                rename_types: PascalCase,
+            },
+        ),
+        Path::new("FooBarCChar")
+    );
+
+    // Foo<Bar<T>> => Foo_Bar_T
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[generic_path("Bar", &[path("T")])],
+            &MangleConfig::default(),
+        ),
+        Path::new("Foo_Bar_T")
+    );
+
+    // Foo<Bar<T>, E> => Foo_Bar_T_____E
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[generic_path("Bar", &[path("T")]), path("E")],
+            &MangleConfig::default(),
+        ),
+        Path::new("Foo_Bar_T_____E")
+    );
+
+    // Foo<Bar<T>, Bar<E>> => Foo_Bar_T_____Bar_E
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[
+                generic_path("Bar", &[path("T")]),
+                generic_path("Bar", &[path("E")]),
+            ],
+            &MangleConfig::default(),
+        ),
+        Path::new("Foo_Bar_T_____Bar_E")
+    );
+
+    // Foo<Bar<T>, E> => FooBarTE
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[generic_path("Bar", &[path("T")]), path("E")],
+            &MangleConfig {
+                remove_underscores: true,
+                rename_types: PascalCase,
+            },
+        ),
+        Path::new("FooBarTE")
+    );
+
+    // Foo<Bar<T>, Bar<E>> => FooBarTBarE
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[
+                generic_path("Bar", &[path("T")]),
+                generic_path("Bar", &[path("E")]),
+            ],
+            &MangleConfig {
+                remove_underscores: true,
+                rename_types: PascalCase,
+            },
+        ),
+        Path::new("FooBarTBarE")
+    );
+
+    assert_eq!(
+        mangle_path(
+            &Path::new("Top"),
+            &[GenericArgument::Const(ConstExpr::Value("40".to_string()))],
+            &MangleConfig::default(),
+        ),
+        Path::new("Top_40")
+    );
+
+    assert_eq!(
+        mangle_path(
+            &Path::new("Top"),
+            &[GenericArgument::Const(ConstExpr::Name("N".to_string()))],
+            &MangleConfig::default(),
+        ),
+        Path::new("Top_N")
+    );
+
+    assert_eq!(
+        mangle_path(
+            &Path::new("Top"),
+            &[generic_path("N", &[])],
+            &MangleConfig::default(),
+        ),
+        Path::new("Top_N")
+    );
+
+    assert_eq!(
+        mangle_path(
+            &Path::new("Foo"),
+            &[
+                float(),
+                GenericArgument::Const(ConstExpr::Value("40".to_string()))
+            ],
+            &MangleConfig::default(),
+        ),
+        Path::new("Foo_f32__40")
+    );
+}
diff --git a/src/bindgen/mod.rs b/src/bindgen/mod.rs
new file mode 100644
index 0000000..d0789da
--- /dev/null
+++ b/src/bindgen/mod.rs
@@ -0,0 +1,65 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/// A helper macro for deriving deserialize for an enum to be used in toml-rs.
+/// This macro works be relying on an existing FromStr implementation for the
+/// desired type.
+macro_rules! deserialize_enum_str {
+    ($name:ident) => {
+        impl<'de> ::serde::Deserialize<'de> for $name {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: ::serde::Deserializer<'de>,
+            {
+                struct Visitor;
+                impl<'de> ::serde::de::Visitor<'de> for Visitor {
+                    type Value = $name;
+
+                    fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                        f.write_str("$name")
+                    }
+
+                    fn visit_str<E>(self, v: &str) -> Result<$name, E>
+                    where
+                        E: ::serde::de::Error,
+                    {
+                        match v.parse::<$name>() {
+                            Ok(v) => Ok(v),
+                            Err(m) => Err(E::custom(m)),
+                        }
+                    }
+                }
+                deserializer.deserialize_str(Visitor)
+            }
+        }
+    };
+}
+
+mod bindings;
+mod bitflags;
+mod builder;
+mod cargo;
+mod cdecl;
+mod config;
+mod declarationtyperesolver;
+mod dependencies;
+mod error;
+mod ir;
+mod library;
+mod mangle;
+mod monomorph;
+mod parser;
+mod rename;
+mod reserved;
+mod utilities;
+mod writer;
+
+#[allow(unused)]
+pub(crate) use self::cargo::*;
+
+pub use self::bindings::Bindings;
+pub use self::builder::Builder;
+pub use self::config::Profile; // disambiguate with cargo::Profile
+pub use self::config::*;
+pub use self::error::Error;
diff --git a/src/bindgen/monomorph.rs b/src/bindgen/monomorph.rs
new file mode 100644
index 0000000..db6dce6
--- /dev/null
+++ b/src/bindgen/monomorph.rs
@@ -0,0 +1,147 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::HashMap;
+use std::mem;
+
+use crate::bindgen::ir::{
+    Enum, GenericArgument, GenericPath, OpaqueItem, Path, Struct, Typedef, Union,
+};
+use crate::bindgen::library::Library;
+
+#[derive(Default, Clone, Debug)]
+pub struct Monomorphs {
+    replacements: HashMap<GenericPath, Path>,
+    opaques: Vec<OpaqueItem>,
+    structs: Vec<Struct>,
+    unions: Vec<Union>,
+    typedefs: Vec<Typedef>,
+    enums: Vec<Enum>,
+}
+
+impl Monomorphs {
+    pub fn contains(&self, path: &GenericPath) -> bool {
+        self.replacements.contains_key(path)
+    }
+
+    pub fn insert_struct(
+        &mut self,
+        library: &Library,
+        generic: &Struct,
+        monomorph: Struct,
+        arguments: Vec<GenericArgument>,
+    ) {
+        let replacement_path = GenericPath::new(generic.path.clone(), arguments);
+
+        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(!self.contains(&replacement_path));
+
+        self.replacements
+            .insert(replacement_path, monomorph.path.clone());
+
+        monomorph.add_monomorphs(library, self);
+
+        self.structs.push(monomorph);
+    }
+
+    pub fn insert_enum(
+        &mut self,
+        library: &Library,
+        generic: &Enum,
+        monomorph: Enum,
+        arguments: Vec<GenericArgument>,
+    ) {
+        let replacement_path = GenericPath::new(generic.path.clone(), arguments);
+
+        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(!self.contains(&replacement_path));
+
+        self.replacements
+            .insert(replacement_path, monomorph.path.clone());
+
+        monomorph.add_monomorphs(library, self);
+
+        self.enums.push(monomorph);
+    }
+
+    pub fn insert_union(
+        &mut self,
+        library: &Library,
+        generic: &Union,
+        monomorph: Union,
+        arguments: Vec<GenericArgument>,
+    ) {
+        let replacement_path = GenericPath::new(generic.path.clone(), arguments);
+
+        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(!self.contains(&replacement_path));
+
+        self.replacements
+            .insert(replacement_path, monomorph.path.clone());
+
+        monomorph.add_monomorphs(library, self);
+
+        self.unions.push(monomorph);
+    }
+
+    pub fn insert_opaque(
+        &mut self,
+        generic: &OpaqueItem,
+        monomorph: OpaqueItem,
+        arguments: Vec<GenericArgument>,
+    ) {
+        let replacement_path = GenericPath::new(generic.path.clone(), arguments);
+
+        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(!self.contains(&replacement_path));
+
+        self.replacements
+            .insert(replacement_path, monomorph.path.clone());
+        self.opaques.push(monomorph);
+    }
+
+    pub fn insert_typedef(
+        &mut self,
+        library: &Library,
+        generic: &Typedef,
+        monomorph: Typedef,
+        arguments: Vec<GenericArgument>,
+    ) {
+        let replacement_path = GenericPath::new(generic.path.clone(), arguments);
+
+        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(!self.contains(&replacement_path));
+
+        self.replacements
+            .insert(replacement_path, monomorph.path.clone());
+
+        monomorph.add_monomorphs(library, self);
+
+        self.typedefs.push(monomorph);
+    }
+
+    pub fn mangle_path(&self, path: &GenericPath) -> Option<&Path> {
+        self.replacements.get(path)
+    }
+
+    pub fn drain_opaques(&mut self) -> Vec<OpaqueItem> {
+        mem::take(&mut self.opaques)
+    }
+
+    pub fn drain_structs(&mut self) -> Vec<Struct> {
+        mem::take(&mut self.structs)
+    }
+
+    pub fn drain_unions(&mut self) -> Vec<Union> {
+        mem::take(&mut self.unions)
+    }
+
+    pub fn drain_typedefs(&mut self) -> Vec<Typedef> {
+        mem::take(&mut self.typedefs)
+    }
+
+    pub fn drain_enums(&mut self) -> Vec<Enum> {
+        mem::take(&mut self.enums)
+    }
+}
diff --git a/src/bindgen/parser.rs b/src/bindgen/parser.rs
new file mode 100644
index 0000000..b54c7fb
--- /dev/null
+++ b/src/bindgen/parser.rs
@@ -0,0 +1,1011 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
+use std::fs::File;
+use std::io::Read;
+use std::path::{Path as FilePath, PathBuf as FilePathBuf};
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::bitflags;
+use crate::bindgen::cargo::{Cargo, PackageRef};
+use crate::bindgen::config::{Config, ParseConfig};
+use crate::bindgen::error::Error;
+use crate::bindgen::ir::{
+    AnnotationSet, AnnotationValue, Cfg, Constant, Documentation, Enum, Function, GenericParam,
+    GenericParams, ItemMap, OpaqueItem, Path, Static, Struct, Type, Typedef, Union,
+};
+use crate::bindgen::utilities::{SynAbiHelpers, SynAttributeHelpers, SynItemHelpers};
+
+const STD_CRATES: &[&str] = &[
+    "std",
+    "std_unicode",
+    "alloc",
+    "collections",
+    "core",
+    "proc_macro",
+];
+
+type ParseResult = Result<Parse, Error>;
+
+/// Parses a single rust source file, not following `mod` or `extern crate`.
+pub fn parse_src(src_file: &FilePath, config: &Config) -> ParseResult {
+    let mod_name = src_file.file_stem().unwrap().to_str().unwrap();
+    let mut config = config.clone();
+    config.parse = ParseConfig {
+        parse_deps: true,
+        ..ParseConfig::default()
+    };
+
+    let mut context = Parser {
+        binding_crate_name: mod_name.to_owned(),
+        config: &config,
+        lib: None,
+        parsed_crates: HashSet::new(),
+        cache_src: HashMap::new(),
+        cache_expanded_crate: HashMap::new(),
+        cfg_stack: Vec::new(),
+        out: Parse::new(),
+    };
+
+    let pkg_ref = PackageRef {
+        name: mod_name.to_owned(),
+        version: None,
+    };
+
+    context.parse_mod(&pkg_ref, src_file, 0)?;
+    context.out.source_files = context.cache_src.keys().map(|k| k.to_owned()).collect();
+    Ok(context.out)
+}
+
+/// Recursively parses a rust library starting at the root crate's directory.
+///
+/// Inside a crate, `mod` and `extern crate` declarations are followed
+/// and parsed. To find an external crate, the parser uses the `cargo metadata`
+/// command to find the location of dependencies.
+pub(crate) fn parse_lib(lib: Cargo, config: &Config) -> ParseResult {
+    let mut context = Parser {
+        binding_crate_name: lib.binding_crate_name().to_owned(),
+        config,
+        lib: Some(lib),
+        parsed_crates: HashSet::new(),
+        cache_src: HashMap::new(),
+        cache_expanded_crate: HashMap::new(),
+        cfg_stack: Vec::new(),
+        out: Parse::new(),
+    };
+
+    let binding_crate = context.lib.as_ref().unwrap().binding_crate_ref();
+    context.parse_crate(&binding_crate)?;
+    context.out.source_files = context.cache_src.keys().map(|k| k.to_owned()).collect();
+    Ok(context.out)
+}
+
+#[derive(Debug, Clone)]
+struct Parser<'a> {
+    binding_crate_name: String,
+    lib: Option<Cargo>,
+    config: &'a Config,
+
+    parsed_crates: HashSet<String>,
+    cache_src: HashMap<FilePathBuf, Vec<syn::Item>>,
+    cache_expanded_crate: HashMap<String, Vec<syn::Item>>,
+
+    cfg_stack: Vec<Cfg>,
+
+    out: Parse,
+}
+
+impl<'a> Parser<'a> {
+    fn should_parse_dependency(&self, pkg_name: &str) -> bool {
+        if self.parsed_crates.contains(pkg_name) {
+            return false;
+        }
+
+        if !self.config.parse.parse_deps {
+            return false;
+        }
+
+        // Skip any whitelist or blacklist for expand
+        if self
+            .config
+            .parse
+            .expand
+            .crates
+            .iter()
+            .any(|name| name == pkg_name)
+        {
+            return true;
+        }
+
+        // If we have a whitelist, check it
+        if let Some(ref include) = self.config.parse.include {
+            if !include.iter().any(|name| name == pkg_name) {
+                debug!("Excluding crate {}", pkg_name);
+                return false;
+            }
+        }
+
+        // Check the blacklist
+        !STD_CRATES.contains(&pkg_name)
+            && !self
+                .config
+                .parse
+                .exclude
+                .iter()
+                .any(|name| name == pkg_name)
+    }
+
+    fn parse_crate(&mut self, pkg: &PackageRef) -> Result<(), Error> {
+        assert!(self.lib.is_some());
+        debug!("Parsing crate {}", pkg.name);
+        self.parsed_crates.insert(pkg.name.clone());
+
+        // Check if we should use cargo expand for this crate
+        if self.config.parse.expand.crates.contains(&pkg.name) {
+            self.parse_expand_crate(pkg)?;
+        } else {
+            // Parse the crate before the dependencies otherwise the same-named idents we
+            // want to generate bindings for would be replaced by the ones provided
+            // by the first dependency containing it.
+            let crate_src = self.lib.as_ref().unwrap().find_crate_src(pkg);
+
+            match crate_src {
+                Some(crate_src) => self.parse_mod(pkg, crate_src.as_path(), 0)?,
+                None => {
+                    // This should be an error, but is common enough to just elicit a warning
+                    warn!(
+                        "Parsing crate `{}`: can't find lib.rs with `cargo metadata`. \
+                        The crate may be available only on a particular platform, \
+                        so consider setting `fetch_all_dependencies` in your cbindgen configuration.",
+                        pkg.name
+                    );
+                }
+            }
+        }
+
+        for (dep_pkg, cfg) in self.lib.as_ref().unwrap().dependencies(pkg) {
+            if !self.should_parse_dependency(&dep_pkg.name) {
+                continue;
+            }
+
+            if let Some(ref cfg) = cfg {
+                self.cfg_stack.push(cfg.clone());
+            }
+
+            self.parse_crate(&dep_pkg)?;
+
+            if cfg.is_some() {
+                self.cfg_stack.pop();
+            }
+        }
+
+        Ok(())
+    }
+
+    fn parse_expand_crate(&mut self, pkg: &PackageRef) -> Result<(), Error> {
+        assert!(self.lib.is_some());
+
+        let mod_items = {
+            if !self.cache_expanded_crate.contains_key(&pkg.name) {
+                let s = self
+                    .lib
+                    .as_ref()
+                    .unwrap()
+                    .expand_crate(
+                        pkg,
+                        self.config.parse.expand.all_features,
+                        self.config.parse.expand.default_features,
+                        &self.config.parse.expand.features,
+                        self.config.parse.expand.profile,
+                    )
+                    .map_err(|x| Error::CargoExpand(pkg.name.clone(), x))?;
+                let i = syn::parse_file(&s).map_err(|x| Error::ParseSyntaxError {
+                    crate_name: pkg.name.clone(),
+                    src_path: "".to_owned(),
+                    error: x,
+                })?;
+                self.cache_expanded_crate.insert(pkg.name.clone(), i.items);
+            }
+
+            self.cache_expanded_crate.get(&pkg.name).unwrap().clone()
+        };
+
+        self.process_mod(
+            pkg, None, None, &mod_items, 0, /* is_mod_rs = */ true,
+            /* is_inline = */ false,
+        )
+    }
+
+    fn parse_mod(
+        &mut self,
+        pkg: &PackageRef,
+        mod_path: &FilePath,
+        depth: usize,
+    ) -> Result<(), Error> {
+        let mod_items = match self.cache_src.entry(mod_path.to_path_buf()) {
+            Entry::Vacant(vacant_entry) => {
+                let mut s = String::new();
+                let mut f = File::open(mod_path).map_err(|_| Error::ParseCannotOpenFile {
+                    crate_name: pkg.name.clone(),
+                    src_path: mod_path.to_str().unwrap().to_owned(),
+                })?;
+
+                f.read_to_string(&mut s)
+                    .map_err(|_| Error::ParseCannotOpenFile {
+                        crate_name: pkg.name.clone(),
+                        src_path: mod_path.to_str().unwrap().to_owned(),
+                    })?;
+
+                let i = syn::parse_file(&s).map_err(|x| Error::ParseSyntaxError {
+                    crate_name: pkg.name.clone(),
+                    src_path: mod_path.to_string_lossy().into(),
+                    error: x,
+                })?;
+
+                vacant_entry.insert(i.items).clone()
+            }
+            Entry::Occupied(occupied_entry) => occupied_entry.get().clone(),
+        };
+
+        // Compute module directory according to Rust 2018 rules
+        let submod_dir_2018;
+
+        let mod_dir = mod_path.parent().unwrap();
+
+        let is_mod_rs = depth == 0 || mod_path.ends_with("mod.rs");
+        let submod_dir = if is_mod_rs {
+            mod_dir
+        } else {
+            submod_dir_2018 = mod_path
+                .parent()
+                .unwrap()
+                .join(mod_path.file_stem().unwrap());
+            &submod_dir_2018
+        };
+
+        self.process_mod(
+            pkg,
+            Some(mod_dir),
+            Some(submod_dir),
+            &mod_items,
+            depth,
+            /* is_inline = */ false,
+            is_mod_rs,
+        )
+    }
+
+    /// `mod_dir` is the path to the current directory of the module. It may be
+    /// `None` for pre-expanded modules.
+    ///
+    /// `submod_dir` is the path to search submodules in by default, which might
+    /// be different for rust 2018 for example.
+    #[allow(clippy::too_many_arguments)]
+    fn process_mod(
+        &mut self,
+        pkg: &PackageRef,
+        mod_dir: Option<&FilePath>,
+        submod_dir: Option<&FilePath>,
+        items: &[syn::Item],
+        depth: usize,
+        is_inline: bool,
+        is_in_mod_rs: bool,
+    ) -> Result<(), Error> {
+        debug_assert_eq!(mod_dir.is_some(), submod_dir.is_some());
+        // We process the items first then the nested modules.
+        let nested_modules = self.out.load_syn_crate_mod(
+            self.config,
+            &self.binding_crate_name,
+            &pkg.name,
+            Cfg::join(&self.cfg_stack).as_ref(),
+            items,
+        );
+
+        for item in nested_modules {
+            let next_mod_name = item.ident.unraw().to_string();
+            let cfg = Cfg::load(&item.attrs);
+            if let Some(ref cfg) = cfg {
+                self.cfg_stack.push(cfg.clone());
+            }
+
+            if let Some((_, ref inline_items)) = item.content {
+                // TODO(emilio): This should use #[path] attribute if present,
+                // rather than next_mod_name.
+                let next_submod_dir = submod_dir.map(|dir| dir.join(&next_mod_name));
+                let next_mod_dir = mod_dir.map(|dir| dir.join(&next_mod_name));
+                self.process_mod(
+                    pkg,
+                    next_mod_dir.as_deref(),
+                    next_submod_dir.as_deref(),
+                    inline_items,
+                    depth,
+                    /* is_inline = */ true,
+                    is_in_mod_rs,
+                )?;
+            } else if let Some(mod_dir) = mod_dir {
+                let submod_dir = submod_dir.unwrap();
+                let next_mod_path1 = submod_dir.join(next_mod_name.clone() + ".rs");
+                let next_mod_path2 = submod_dir.join(next_mod_name.clone()).join("mod.rs");
+
+                if next_mod_path1.exists() {
+                    self.parse_mod(pkg, next_mod_path1.as_path(), depth + 1)?;
+                } else if next_mod_path2.exists() {
+                    self.parse_mod(pkg, next_mod_path2.as_path(), depth + 1)?;
+                } else {
+                    // Last chance to find a module path
+                    let mut path_attr_found = false;
+                    for attr in &item.attrs {
+                        if let Ok(syn::Meta::NameValue(syn::MetaNameValue { path, lit, .. })) =
+                            attr.parse_meta()
+                        {
+                            match lit {
+                                syn::Lit::Str(ref path_lit) if path.is_ident("path") => {
+                                    path_attr_found = true;
+                                    // https://doc.rust-lang.org/reference/items/modules.html#the-path-attribute
+                                    //
+                                    //     For path attributes on modules not inside inline module blocks, the file path
+                                    //     is relative to the directory the source file is located.
+                                    //
+                                    //     For path attributes inside inline module blocks, the relative location of the
+                                    //     file path depends on the kind of source file the path attribute is located
+                                    //     in.  "mod-rs" source files are root modules (such as lib.rs or main.rs) and
+                                    //     modules with files named mod.rs. "non-mod-rs" source files are all other
+                                    //     module files.
+                                    //
+                                    //     Paths for path attributes inside inline module blocks in a mod-rs file are
+                                    //     relative to the directory of the mod-rs file including the inline module
+                                    //     components as directories. For non-mod-rs files, it is the same except the
+                                    //     path starts with a directory with the name of the non-mod-rs module.
+                                    //
+                                    let base = if is_inline && !is_in_mod_rs {
+                                        submod_dir
+                                    } else {
+                                        mod_dir
+                                    };
+                                    self.parse_mod(pkg, &base.join(path_lit.value()), depth + 1)?;
+                                    break;
+                                }
+                                _ => (),
+                            }
+                        }
+                    }
+
+                    // This should be an error, but it's common enough to
+                    // just elicit a warning
+                    if !path_attr_found {
+                        warn!(
+                            "Parsing crate `{}`: can't find mod {}`.",
+                            pkg.name, next_mod_name
+                        );
+                    }
+                }
+            } else {
+                warn!(
+                    "Parsing expanded crate `{}`: can't find mod {}`.",
+                    pkg.name, next_mod_name
+                );
+            }
+
+            if cfg.is_some() {
+                self.cfg_stack.pop();
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Parse {
+    pub constants: ItemMap<Constant>,
+    pub globals: ItemMap<Static>,
+    pub enums: ItemMap<Enum>,
+    pub structs: ItemMap<Struct>,
+    pub unions: ItemMap<Union>,
+    pub opaque_items: ItemMap<OpaqueItem>,
+    pub typedefs: ItemMap<Typedef>,
+    pub functions: Vec<Function>,
+    pub source_files: Vec<FilePathBuf>,
+}
+
+impl Parse {
+    pub fn new() -> Parse {
+        Parse {
+            constants: ItemMap::default(),
+            globals: ItemMap::default(),
+            enums: ItemMap::default(),
+            structs: ItemMap::default(),
+            unions: ItemMap::default(),
+            opaque_items: ItemMap::default(),
+            typedefs: ItemMap::default(),
+            functions: Vec::new(),
+            source_files: Vec::new(),
+        }
+    }
+
+    pub fn add_std_types(&mut self) {
+        let mut add_opaque = |path: &str, generic_params: Vec<&str>| {
+            let path = Path::new(path);
+            let generic_params: Vec<_> = generic_params
+                .into_iter()
+                .map(GenericParam::new_type_param)
+                .collect();
+            self.opaque_items.try_insert(OpaqueItem::new(
+                path,
+                GenericParams(generic_params),
+                None,
+                AnnotationSet::new(),
+                Documentation::none(),
+            ))
+        };
+
+        add_opaque("String", vec![]);
+        add_opaque("Box", vec!["T"]);
+        add_opaque("RefCell", vec!["T"]);
+        add_opaque("Rc", vec!["T"]);
+        add_opaque("Arc", vec!["T"]);
+        add_opaque("Result", vec!["T", "E"]);
+        add_opaque("Option", vec!["T"]);
+        add_opaque("NonNull", vec!["T"]);
+        add_opaque("Vec", vec!["T"]);
+        add_opaque("HashMap", vec!["K", "V", "Hasher"]);
+        add_opaque("BTreeMap", vec!["K", "V"]);
+        add_opaque("HashSet", vec!["T"]);
+        add_opaque("BTreeSet", vec!["T"]);
+        add_opaque("LinkedList", vec!["T"]);
+        add_opaque("VecDeque", vec!["T"]);
+        add_opaque("ManuallyDrop", vec!["T"]);
+        add_opaque("MaybeUninit", vec!["T"]);
+    }
+
+    pub fn extend_with(&mut self, other: &Parse) {
+        self.constants.extend_with(&other.constants);
+        self.globals.extend_with(&other.globals);
+        self.enums.extend_with(&other.enums);
+        self.structs.extend_with(&other.structs);
+        self.unions.extend_with(&other.unions);
+        self.opaque_items.extend_with(&other.opaque_items);
+        self.typedefs.extend_with(&other.typedefs);
+        self.functions.extend_from_slice(&other.functions);
+        self.source_files.extend_from_slice(&other.source_files);
+    }
+
+    fn load_syn_crate_mod<'a>(
+        &mut self,
+        config: &Config,
+        binding_crate_name: &str,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        items: &'a [syn::Item],
+    ) -> Vec<&'a syn::ItemMod> {
+        let mut impls_with_assoc_consts = Vec::new();
+        let mut nested_modules = Vec::new();
+
+        for item in items {
+            if item.should_skip_parsing() {
+                continue;
+            }
+            match item {
+                syn::Item::ForeignMod(ref item) => {
+                    self.load_syn_foreign_mod(
+                        config,
+                        binding_crate_name,
+                        crate_name,
+                        mod_cfg,
+                        item,
+                    );
+                }
+                syn::Item::Fn(ref item) => {
+                    self.load_syn_fn(config, binding_crate_name, crate_name, mod_cfg, item);
+                }
+                syn::Item::Const(ref item) => {
+                    self.load_syn_const(config, binding_crate_name, crate_name, mod_cfg, item);
+                }
+                syn::Item::Static(ref item) => {
+                    self.load_syn_static(config, binding_crate_name, crate_name, mod_cfg, item);
+                }
+                syn::Item::Struct(ref item) => {
+                    self.load_syn_struct(config, crate_name, mod_cfg, item);
+                }
+                syn::Item::Union(ref item) => {
+                    self.load_syn_union(config, crate_name, mod_cfg, item);
+                }
+                syn::Item::Enum(ref item) => {
+                    self.load_syn_enum(config, crate_name, mod_cfg, item);
+                }
+                syn::Item::Type(ref item) => {
+                    self.load_syn_ty(crate_name, mod_cfg, item);
+                }
+                syn::Item::Impl(ref item_impl) => {
+                    let has_assoc_const = item_impl
+                        .items
+                        .iter()
+                        .any(|item| matches!(item, syn::ImplItem::Const(_)));
+                    if has_assoc_const {
+                        impls_with_assoc_consts.push(item_impl);
+                    }
+
+                    if let syn::Type::Path(ref path) = *item_impl.self_ty {
+                        if let Some(type_name) = path.path.get_ident() {
+                            for method in item_impl.items.iter().filter_map(|item| match item {
+                                syn::ImplItem::Method(method) => Some(method),
+                                _ => None,
+                            }) {
+                                self.load_syn_method(
+                                    config,
+                                    binding_crate_name,
+                                    crate_name,
+                                    mod_cfg,
+                                    &Path::new(type_name.unraw().to_string()),
+                                    method,
+                                )
+                            }
+                        }
+                    }
+                }
+                syn::Item::Macro(ref item) => {
+                    self.load_builtin_macro(config, crate_name, mod_cfg, item);
+                }
+                syn::Item::Mod(ref item) => {
+                    nested_modules.push(item);
+                }
+                _ => {}
+            }
+        }
+
+        for item_impl in impls_with_assoc_consts {
+            self.load_syn_assoc_consts_from_impl(crate_name, mod_cfg, item_impl)
+        }
+
+        nested_modules
+    }
+
+    fn load_syn_assoc_consts_from_impl(
+        &mut self,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item_impl: &syn::ItemImpl,
+    ) {
+        let associated_constants = item_impl.items.iter().filter_map(|item| match item {
+            syn::ImplItem::Const(ref associated_constant) => Some(associated_constant),
+            _ => None,
+        });
+        self.load_syn_assoc_consts(
+            crate_name,
+            mod_cfg,
+            &item_impl.self_ty,
+            associated_constants,
+        );
+    }
+
+    /// Enters a `extern "C" { }` declaration and loads function declarations.
+    fn load_syn_foreign_mod(
+        &mut self,
+        config: &Config,
+        binding_crate_name: &str,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemForeignMod,
+    ) {
+        if !item.abi.is_c() {
+            info!("Skip {} - (extern block must be extern C).", crate_name);
+            return;
+        }
+
+        for foreign_item in &item.items {
+            if let syn::ForeignItem::Fn(ref function) = *foreign_item {
+                if !config
+                    .parse
+                    .should_generate_top_level_item(crate_name, binding_crate_name)
+                {
+                    info!(
+                        "Skip {}::{} - (fn's outside of the binding crate are not used).",
+                        crate_name, &function.sig.ident
+                    );
+                    return;
+                }
+                let path = Path::new(function.sig.ident.unraw().to_string());
+                match Function::load(path, None, &function.sig, true, &function.attrs, mod_cfg) {
+                    Ok(func) => {
+                        info!("Take {}::{}.", crate_name, &function.sig.ident);
+
+                        self.functions.push(func);
+                    }
+                    Err(msg) => {
+                        error!(
+                            "Cannot use fn {}::{} ({}).",
+                            crate_name, &function.sig.ident, msg
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    /// Loads a `fn` declaration inside an `impl` block, if the type is a simple identifier
+    fn load_syn_method(
+        &mut self,
+        config: &Config,
+        binding_crate_name: &str,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        self_type: &Path,
+        item: &syn::ImplItemMethod,
+    ) {
+        self.load_fn_declaration(
+            config,
+            binding_crate_name,
+            crate_name,
+            mod_cfg,
+            item,
+            Some(self_type),
+            &item.sig,
+            &item.attrs,
+        )
+    }
+
+    /// Loads a `fn` declaration
+    fn load_syn_fn(
+        &mut self,
+        config: &Config,
+        binding_crate_name: &str,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemFn,
+    ) {
+        self.load_fn_declaration(
+            config,
+            binding_crate_name,
+            crate_name,
+            mod_cfg,
+            item,
+            None,
+            &item.sig,
+            &item.attrs,
+        );
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn load_fn_declaration(
+        &mut self,
+        config: &Config,
+        binding_crate_name: &str,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        named_symbol: &dyn SynItemHelpers,
+        self_type: Option<&Path>,
+        sig: &syn::Signature,
+        attrs: &[syn::Attribute],
+    ) {
+        if !config
+            .parse
+            .should_generate_top_level_item(crate_name, binding_crate_name)
+        {
+            info!(
+                "Skip {}::{} - (fn's outside of the binding crate are not used).",
+                crate_name, &sig.ident
+            );
+            return;
+        }
+
+        let loggable_item_name = || {
+            let mut items = Vec::with_capacity(3);
+            items.push(crate_name.to_owned());
+            if let Some(ref self_type) = self_type {
+                items.push(self_type.to_string());
+            }
+            items.push(sig.ident.unraw().to_string());
+            items.join("::")
+        };
+
+        let is_extern_c = sig.abi.is_omitted() || sig.abi.is_c();
+        let exported_name = named_symbol.exported_name();
+
+        match (is_extern_c, exported_name) {
+            (true, Some(exported_name)) => {
+                let path = Path::new(exported_name);
+                match Function::load(path, self_type, sig, false, attrs, mod_cfg) {
+                    Ok(func) => {
+                        info!("Take {}.", loggable_item_name());
+                        self.functions.push(func);
+                    }
+                    Err(msg) => {
+                        error!("Cannot use fn {} ({}).", loggable_item_name(), msg);
+                    }
+                }
+            }
+            (true, None) => {
+                warn!(
+                    "Skipping {} - (not `no_mangle`, and has no `export_name` attribute)",
+                    loggable_item_name()
+                );
+            }
+            (false, Some(_exported_name)) => {
+                warn!("Skipping {} - (not `extern \"C\"`", loggable_item_name());
+            }
+            (false, None) => {}
+        }
+    }
+
+    /// Loads associated `const` declarations
+    fn load_syn_assoc_consts<'a, I>(
+        &mut self,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        impl_ty: &syn::Type,
+        items: I,
+    ) where
+        I: IntoIterator<Item = &'a syn::ImplItemConst>,
+    {
+        let ty = match Type::load(impl_ty) {
+            Ok(ty) => ty,
+            Err(e) => {
+                warn!("Skipping associated constants for {:?}: {:?}", impl_ty, e);
+                return;
+            }
+        };
+
+        let ty = match ty {
+            Some(ty) => ty,
+            None => return,
+        };
+
+        let impl_path = match ty.get_root_path() {
+            Some(p) => p,
+            None => {
+                warn!(
+                    "Couldn't find path for {:?}, skipping associated constants",
+                    ty
+                );
+                return;
+            }
+        };
+
+        for item in items.into_iter() {
+            if let syn::Visibility::Public(_) = item.vis {
+            } else {
+                warn!("Skip {}::{} - (not `pub`).", crate_name, &item.ident);
+                return;
+            }
+
+            let path = Path::new(item.ident.unraw().to_string());
+            match Constant::load(
+                path,
+                mod_cfg,
+                &item.ty,
+                &item.expr,
+                &item.attrs,
+                Some(impl_path.clone()),
+            ) {
+                Ok(constant) => {
+                    info!("Take {}::{}::{}.", crate_name, impl_path, &item.ident);
+                    let mut any = false;
+                    self.structs.for_items_mut(&impl_path, |item| {
+                        any = true;
+                        item.add_associated_constant(constant.clone());
+                    });
+                    // Handle associated constants to other item types that are
+                    // not structs like enums or such as regular constants.
+                    if !any && !self.constants.try_insert(constant) {
+                        error!(
+                            "Conflicting name for constant {}::{}::{}.",
+                            crate_name, impl_path, &item.ident,
+                        );
+                    }
+                }
+                Err(msg) => {
+                    warn!("Skip {}::{} - ({})", crate_name, &item.ident, msg);
+                }
+            }
+        }
+    }
+
+    /// Loads a `const` declaration
+    fn load_syn_const(
+        &mut self,
+        config: &Config,
+        binding_crate_name: &str,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemConst,
+    ) {
+        if !config
+            .parse
+            .should_generate_top_level_item(crate_name, binding_crate_name)
+        {
+            info!(
+                "Skip {}::{} - (const's outside of the binding crate are not used).",
+                crate_name, &item.ident
+            );
+            return;
+        }
+
+        if let syn::Visibility::Public(_) = item.vis {
+        } else {
+            warn!("Skip {}::{} - (not `pub`).", crate_name, &item.ident);
+            return;
+        }
+
+        let path = Path::new(item.ident.unraw().to_string());
+        match Constant::load(path, mod_cfg, &item.ty, &item.expr, &item.attrs, None) {
+            Ok(constant) => {
+                info!("Take {}::{}.", crate_name, &item.ident);
+
+                let full_name = constant.path.clone();
+                if !self.constants.try_insert(constant) {
+                    error!("Conflicting name for constant {}", full_name);
+                }
+            }
+            Err(msg) => {
+                warn!("Skip {}::{} - ({})", crate_name, &item.ident, msg);
+            }
+        }
+    }
+
+    /// Loads a `static` declaration
+    fn load_syn_static(
+        &mut self,
+        config: &Config,
+        binding_crate_name: &str,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemStatic,
+    ) {
+        if !config
+            .parse
+            .should_generate_top_level_item(crate_name, binding_crate_name)
+        {
+            info!(
+                "Skip {}::{} - (static's outside of the binding crate are not used).",
+                crate_name, &item.ident
+            );
+            return;
+        }
+
+        if let Some(exported_name) = item.exported_name() {
+            let path = Path::new(exported_name);
+            match Static::load(path, item, mod_cfg) {
+                Ok(constant) => {
+                    info!("Take {}::{}.", crate_name, &item.ident);
+                    self.globals.try_insert(constant);
+                }
+                Err(msg) => {
+                    warn!("Skip {}::{} - ({})", crate_name, &item.ident, msg);
+                }
+            }
+        } else {
+            warn!("Skip {}::{} - (not `no_mangle`).", crate_name, &item.ident);
+        }
+    }
+
+    /// Loads a `struct` declaration
+    fn load_syn_struct(
+        &mut self,
+        config: &Config,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemStruct,
+    ) {
+        match Struct::load(&config.layout, item, mod_cfg) {
+            Ok(st) => {
+                info!("Take {}::{}.", crate_name, &item.ident);
+                self.structs.try_insert(st);
+            }
+            Err(msg) => {
+                info!("Take {}::{} - opaque ({}).", crate_name, &item.ident, msg);
+                let path = Path::new(item.ident.unraw().to_string());
+                self.opaque_items.try_insert(
+                    OpaqueItem::load(path, &item.generics, &item.attrs, mod_cfg).unwrap(),
+                );
+            }
+        }
+    }
+
+    /// Loads a `union` declaration
+    fn load_syn_union(
+        &mut self,
+        config: &Config,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemUnion,
+    ) {
+        match Union::load(&config.layout, item, mod_cfg) {
+            Ok(st) => {
+                info!("Take {}::{}.", crate_name, &item.ident);
+
+                self.unions.try_insert(st);
+            }
+            Err(msg) => {
+                info!("Take {}::{} - opaque ({}).", crate_name, &item.ident, msg);
+                let path = Path::new(item.ident.unraw().to_string());
+                self.opaque_items.try_insert(
+                    OpaqueItem::load(path, &item.generics, &item.attrs, mod_cfg).unwrap(),
+                );
+            }
+        }
+    }
+
+    /// Loads a `enum` declaration
+    fn load_syn_enum(
+        &mut self,
+        config: &Config,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemEnum,
+    ) {
+        match Enum::load(item, mod_cfg, config) {
+            Ok(en) => {
+                info!("Take {}::{}.", crate_name, &item.ident);
+                self.enums.try_insert(en);
+            }
+            Err(msg) => {
+                info!("Take {}::{} - opaque ({}).", crate_name, &item.ident, msg);
+                let path = Path::new(item.ident.unraw().to_string());
+                self.opaque_items.try_insert(
+                    OpaqueItem::load(path, &item.generics, &item.attrs, mod_cfg).unwrap(),
+                );
+            }
+        }
+    }
+
+    /// Loads a `type` declaration
+    fn load_syn_ty(&mut self, crate_name: &str, mod_cfg: Option<&Cfg>, item: &syn::ItemType) {
+        match Typedef::load(item, mod_cfg) {
+            Ok(st) => {
+                info!("Take {}::{}.", crate_name, &item.ident);
+
+                self.typedefs.try_insert(st);
+            }
+            Err(msg) => {
+                info!("Take {}::{} - opaque ({}).", crate_name, &item.ident, msg);
+                let path = Path::new(item.ident.unraw().to_string());
+                self.opaque_items.try_insert(
+                    OpaqueItem::load(path, &item.generics, &item.attrs, mod_cfg).unwrap(),
+                );
+            }
+        }
+    }
+
+    fn load_builtin_macro(
+        &mut self,
+        config: &Config,
+        crate_name: &str,
+        mod_cfg: Option<&Cfg>,
+        item: &syn::ItemMacro,
+    ) {
+        let name = match item.mac.path.segments.last() {
+            Some(n) => n.ident.unraw().to_string(),
+            None => return,
+        };
+
+        if name != "bitflags" || !config.macro_expansion.bitflags {
+            return;
+        }
+
+        let bitflags = match bitflags::parse(item.mac.tokens.clone()) {
+            Ok(bf) => bf,
+            Err(e) => {
+                warn!("Failed to parse bitflags invocation: {:?}", e);
+                return;
+            }
+        };
+
+        let (struct_, impl_) = bitflags.expand();
+        if let Some(struct_) = struct_ {
+            self.load_syn_struct(config, crate_name, mod_cfg, &struct_);
+        }
+        if let syn::Type::Path(ref path) = *impl_.self_ty {
+            if let Some(type_name) = path.path.get_ident() {
+                self.structs
+                    .for_items_mut(&Path::new(type_name.unraw().to_string()), |item| {
+                        item.annotations
+                            .add_default("internal-derive-bitflags", AnnotationValue::Bool(true));
+                    });
+            }
+        }
+        self.load_syn_assoc_consts_from_impl(crate_name, mod_cfg, &impl_)
+    }
+}
diff --git a/src/bindgen/rename.rs b/src/bindgen/rename.rs
new file mode 100644
index 0000000..f594939
--- /dev/null
+++ b/src/bindgen/rename.rs
@@ -0,0 +1,140 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::borrow::Cow;
+use std::str::FromStr;
+
+/// The type of identifier to be renamed.
+#[derive(Debug, Clone, Copy)]
+pub enum IdentifierType<'a> {
+    StructMember,
+    EnumVariant { prefix: &'a str },
+    FunctionArg,
+    Type,
+    Enum,
+}
+
+impl<'a> IdentifierType<'a> {
+    fn to_str(self) -> &'static str {
+        match self {
+            IdentifierType::StructMember => "m",
+            IdentifierType::EnumVariant { .. } => "",
+            IdentifierType::FunctionArg => "a",
+            IdentifierType::Type => "",
+            IdentifierType::Enum => "",
+        }
+    }
+}
+
+/// A rule to apply to an identifier when generating bindings.
+#[derive(Debug, Clone, Copy, Default)]
+pub enum RenameRule {
+    /// Do not apply any renaming. The default.
+    #[default]
+    None,
+    /// Converts the identifier to PascalCase and adds a context dependent prefix
+    GeckoCase,
+    /// Converts the identifier to lower case.
+    LowerCase,
+    /// Converts the identifier to upper case.
+    UpperCase,
+    /// Converts the identifier to PascalCase.
+    PascalCase,
+    /// Converts the identifier to camelCase.
+    CamelCase,
+    /// Converts the identifier to snake_case.
+    SnakeCase,
+    /// Converts the identifier to SCREAMING_SNAKE_CASE.
+    ScreamingSnakeCase,
+    /// Converts the identifier to SCREAMING_SNAKE_CASE and prefixes enum variants
+    /// with the enum name.
+    QualifiedScreamingSnakeCase,
+}
+
+impl RenameRule {
+    pub(crate) fn not_none(self) -> Option<Self> {
+        match self {
+            RenameRule::None => None,
+            other => Some(other),
+        }
+    }
+
+    /// Applies the rename rule to a string
+    pub fn apply<'a>(self, text: &'a str, context: IdentifierType) -> Cow<'a, str> {
+        use heck::*;
+
+        if text.is_empty() {
+            return Cow::Borrowed(text);
+        }
+
+        Cow::Owned(match self {
+            RenameRule::None => return Cow::Borrowed(text),
+            RenameRule::GeckoCase => context.to_str().to_owned() + &text.to_upper_camel_case(),
+            RenameRule::LowerCase => text.to_lowercase(),
+            RenameRule::UpperCase => text.to_uppercase(),
+            RenameRule::PascalCase => text.to_pascal_case(),
+            RenameRule::CamelCase => text.to_lower_camel_case(),
+            RenameRule::SnakeCase => text.to_snake_case(),
+            RenameRule::ScreamingSnakeCase => text.to_shouty_snake_case(),
+            RenameRule::QualifiedScreamingSnakeCase => {
+                let mut result = String::new();
+
+                if let IdentifierType::EnumVariant { prefix } = context {
+                    result.push_str(
+                        &RenameRule::ScreamingSnakeCase.apply(prefix, IdentifierType::Enum),
+                    );
+                    result.push('_');
+                }
+
+                result.push_str(&RenameRule::ScreamingSnakeCase.apply(text, context));
+                result
+            }
+        })
+    }
+}
+
+impl FromStr for RenameRule {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<RenameRule, Self::Err> {
+        match s {
+            "none" => Ok(RenameRule::None),
+            "None" => Ok(RenameRule::None),
+
+            "mGeckoCase" => Ok(RenameRule::GeckoCase),
+            "GeckoCase" => Ok(RenameRule::GeckoCase),
+            "gecko_case" => Ok(RenameRule::GeckoCase),
+
+            "lowercase" => Ok(RenameRule::LowerCase),
+            "LowerCase" => Ok(RenameRule::LowerCase),
+            "lower_case" => Ok(RenameRule::LowerCase),
+
+            "UPPERCASE" => Ok(RenameRule::UpperCase),
+            "UpperCase" => Ok(RenameRule::UpperCase),
+            "upper_case" => Ok(RenameRule::UpperCase),
+
+            "PascalCase" => Ok(RenameRule::PascalCase),
+            "pascal_case" => Ok(RenameRule::PascalCase),
+
+            "camelCase" => Ok(RenameRule::CamelCase),
+            "CamelCase" => Ok(RenameRule::CamelCase),
+            "camel_case" => Ok(RenameRule::CamelCase),
+
+            "snake_case" => Ok(RenameRule::SnakeCase),
+            "SnakeCase" => Ok(RenameRule::SnakeCase),
+
+            "SCREAMING_SNAKE_CASE" => Ok(RenameRule::ScreamingSnakeCase),
+            "ScreamingSnakeCase" => Ok(RenameRule::ScreamingSnakeCase),
+            "screaming_snake_case" => Ok(RenameRule::ScreamingSnakeCase),
+
+            "QUALIFIED_SCREAMING_SNAKE_CASE" => Ok(RenameRule::QualifiedScreamingSnakeCase),
+            "QualifiedScreamingSnakeCase" => Ok(RenameRule::QualifiedScreamingSnakeCase),
+            "qualified_screaming_snake_case" => Ok(RenameRule::QualifiedScreamingSnakeCase),
+
+            _ => Err(format!("Unrecognized RenameRule: '{}'.", s)),
+        }
+    }
+}
+
+deserialize_enum_str!(RenameRule);
diff --git a/src/bindgen/reserved.rs b/src/bindgen/reserved.rs
new file mode 100644
index 0000000..4983f99
--- /dev/null
+++ b/src/bindgen/reserved.rs
@@ -0,0 +1,91 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/// Taken from `https://en.cppreference.com/w/cpp/keyword`
+/// Some experimental keywords were filtered out and the resulting list was
+/// sorted using a rust program.
+const RESERVED_KEYWORDS: &[&str] = &[
+    "alignas",
+    "alignof",
+    "auto",
+    "bool",
+    "break",
+    "case",
+    "catch",
+    "char",
+    "char16_t",
+    "char32_t",
+    "char8_t",
+    "class",
+    "const",
+    "const_cast",
+    "consteval",
+    "constexpr",
+    "continue",
+    "decltype",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "dynamic_cast",
+    "else",
+    "enum",
+    "explicit",
+    "export",
+    "extern",
+    "false",
+    "float",
+    "for",
+    "friend",
+    "goto",
+    "if",
+    "inline",
+    "int",
+    "long",
+    "mutable",
+    "namespace",
+    "new",
+    "noexcept",
+    "nullptr",
+    "operator",
+    "private",
+    "protected",
+    "public",
+    "register",
+    "reinterpret_cast",
+    "return",
+    "short",
+    "signed",
+    "sizeof",
+    "static",
+    "static_assert",
+    "static_cast",
+    "struct",
+    "switch",
+    "template",
+    "this",
+    "thread_local",
+    "throw",
+    "true",
+    "try",
+    "typedef",
+    "typename",
+    "union",
+    "unsigned",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "wchar_t",
+    "while",
+];
+
+pub fn escape(rust_identifier: &mut String) {
+    if RESERVED_KEYWORDS
+        .binary_search(&rust_identifier.as_ref())
+        .is_ok()
+    {
+        rust_identifier.push('_');
+    }
+}
diff --git a/src/bindgen/utilities.rs b/src/bindgen/utilities.rs
new file mode 100644
index 0000000..0e314b9
--- /dev/null
+++ b/src/bindgen/utilities.rs
@@ -0,0 +1,348 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#![allow(clippy::redundant_closure_call)]
+
+use syn::ext::IdentExt;
+
+pub trait IterHelpers: Iterator {
+    fn try_skip_map<F, T, E>(&mut self, f: F) -> Result<Vec<T>, E>
+    where
+        F: FnMut(&Self::Item) -> Result<Option<T>, E>;
+}
+
+impl<I> IterHelpers for I
+where
+    I: Iterator,
+{
+    fn try_skip_map<F, T, E>(&mut self, mut f: F) -> Result<Vec<T>, E>
+    where
+        F: FnMut(&Self::Item) -> Result<Option<T>, E>,
+    {
+        let mut out = Vec::new();
+        for item in self {
+            if let Some(x) = f(&item)? {
+                out.push(x);
+            }
+        }
+        Ok(out)
+    }
+}
+
+pub trait SynItemHelpers: SynAttributeHelpers {
+    fn exported_name(&self) -> Option<String>;
+}
+
+impl SynItemHelpers for syn::ItemFn {
+    fn exported_name(&self) -> Option<String> {
+        self.attrs
+            .attr_name_value_lookup("export_name")
+            .or_else(|| {
+                if self.is_no_mangle() {
+                    Some(self.sig.ident.unraw().to_string())
+                } else {
+                    None
+                }
+            })
+    }
+}
+
+impl SynItemHelpers for syn::ImplItemMethod {
+    fn exported_name(&self) -> Option<String> {
+        self.attrs
+            .attr_name_value_lookup("export_name")
+            .or_else(|| {
+                if self.is_no_mangle() {
+                    Some(self.sig.ident.unraw().to_string())
+                } else {
+                    None
+                }
+            })
+    }
+}
+
+impl SynItemHelpers for syn::ItemStatic {
+    fn exported_name(&self) -> Option<String> {
+        self.attrs
+            .attr_name_value_lookup("export_name")
+            .or_else(|| {
+                if self.is_no_mangle() {
+                    Some(self.ident.unraw().to_string())
+                } else {
+                    None
+                }
+            })
+    }
+}
+
+/// Returns whether this attribute causes us to skip at item. This basically
+/// checks for `#[cfg(test)]`, `#[test]`, `/// cbindgen::ignore` and
+/// variations thereof.
+fn is_skip_item_attr(attr: &syn::Meta) -> bool {
+    match *attr {
+        syn::Meta::Path(ref path) => {
+            // TODO(emilio): It'd be great if rustc allowed us to use a syntax
+            // like `#[cbindgen::ignore]` or such.
+            path.is_ident("test")
+        }
+        syn::Meta::List(ref list) => {
+            if !list.path.is_ident("cfg") {
+                return false;
+            }
+            list.nested.iter().any(|nested| match *nested {
+                syn::NestedMeta::Meta(ref meta) => is_skip_item_attr(meta),
+                syn::NestedMeta::Lit(..) => false,
+            })
+        }
+        syn::Meta::NameValue(ref name_value) => {
+            if name_value.path.is_ident("doc") {
+                if let syn::Lit::Str(ref content) = name_value.lit {
+                    // FIXME(emilio): Maybe should use the general annotation
+                    // mechanism, but it seems overkill for this.
+                    if content.value().trim() == "cbindgen:ignore" {
+                        return true;
+                    }
+                }
+            }
+            false
+        }
+    }
+}
+
+pub trait SynAttributeHelpers {
+    /// Returns the list of attributes for an item.
+    fn attrs(&self) -> &[syn::Attribute];
+
+    /// Searches for attributes like `#[test]`.
+    /// Example:
+    /// - `item.has_attr_word("test")` => `#[test]`
+    fn has_attr_word(&self, name: &str) -> bool {
+        self.attrs()
+            .iter()
+            .filter_map(|x| x.parse_meta().ok())
+            .any(|attr| {
+                if let syn::Meta::Path(ref path) = attr {
+                    path.is_ident(name)
+                } else {
+                    false
+                }
+            })
+    }
+
+    fn find_deprecated_note(&self) -> Option<String> {
+        let attrs = self.attrs();
+        // #[deprecated = ""]
+        if let Some(note) = attrs.attr_name_value_lookup("deprecated") {
+            return Some(note);
+        }
+
+        // #[deprecated]
+        if attrs.has_attr_word("deprecated") {
+            return Some(String::new());
+        }
+
+        // #[deprecated(note = "")]
+        let attr = attrs.iter().find(|attr| {
+            if let Ok(syn::Meta::List(list)) = attr.parse_meta() {
+                list.path.is_ident("deprecated")
+            } else {
+                false
+            }
+        })?;
+
+        let args: syn::punctuated::Punctuated<syn::MetaNameValue, Token![,]> =
+            match attr.parse_args_with(syn::punctuated::Punctuated::parse_terminated) {
+                Ok(args) => args,
+                Err(_) => {
+                    warn!("couldn't parse deprecated attribute");
+                    return None;
+                }
+            };
+
+        let arg = args.iter().find(|arg| arg.path.is_ident("note"))?;
+        if let syn::Lit::Str(ref lit) = arg.lit {
+            Some(lit.value())
+        } else {
+            warn!("deprecated attribute must be a string");
+            None
+        }
+    }
+
+    fn is_no_mangle(&self) -> bool {
+        self.has_attr_word("no_mangle")
+    }
+
+    /// Sees whether we should skip parsing a given item.
+    fn should_skip_parsing(&self) -> bool {
+        for attr in self.attrs() {
+            let meta = match attr.parse_meta() {
+                Ok(attr) => attr,
+                Err(..) => return false,
+            };
+            if is_skip_item_attr(&meta) {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    fn attr_name_value_lookup(&self, name: &str) -> Option<String> {
+        self.attrs()
+            .iter()
+            .filter_map(|attr| {
+                let attr = attr.parse_meta().ok()?;
+                if let syn::Meta::NameValue(syn::MetaNameValue {
+                    path,
+                    lit: syn::Lit::Str(lit),
+                    ..
+                }) = attr
+                {
+                    if path.is_ident(name) {
+                        return Some(lit.value());
+                    }
+                }
+                None
+            })
+            .next()
+    }
+
+    fn get_comment_lines(&self) -> Vec<String> {
+        let mut comment = Vec::new();
+
+        for attr in self.attrs() {
+            if attr.style == syn::AttrStyle::Outer {
+                if let Ok(syn::Meta::NameValue(syn::MetaNameValue {
+                    path,
+                    lit: syn::Lit::Str(content),
+                    ..
+                })) = attr.parse_meta()
+                {
+                    if path.is_ident("doc") {
+                        comment.extend(split_doc_attr(&content.value()));
+                    }
+                }
+            }
+        }
+
+        comment
+    }
+}
+
+macro_rules! syn_item_match_helper {
+    ($s:ident => has_attrs: |$i:ident| $a:block, otherwise: || $b:block) => {
+        match *$s {
+            syn::Item::Const(ref $i) => $a,
+            syn::Item::Enum(ref $i) => $a,
+            syn::Item::ExternCrate(ref $i) => $a,
+            syn::Item::Fn(ref $i) => $a,
+            syn::Item::ForeignMod(ref $i) => $a,
+            syn::Item::Impl(ref $i) => $a,
+            syn::Item::Macro(ref $i) => $a,
+            syn::Item::Macro2(ref $i) => $a,
+            syn::Item::Mod(ref $i) => $a,
+            syn::Item::Static(ref $i) => $a,
+            syn::Item::Struct(ref $i) => $a,
+            syn::Item::Trait(ref $i) => $a,
+            syn::Item::Type(ref $i) => $a,
+            syn::Item::Union(ref $i) => $a,
+            syn::Item::Use(ref $i) => $a,
+            syn::Item::TraitAlias(ref $i) => $a,
+            syn::Item::Verbatim(_) => $b,
+            _ => panic!("Unhandled syn::Item:  {:?}", $s),
+        }
+    };
+}
+
+impl SynAttributeHelpers for syn::Item {
+    fn attrs(&self) -> &[syn::Attribute] {
+        syn_item_match_helper!(self =>
+            has_attrs: |item| { &item.attrs },
+            otherwise: || { &[] }
+        )
+    }
+}
+
+macro_rules! impl_syn_item_helper {
+    ($t:ty) => {
+        impl SynAttributeHelpers for $t {
+            fn attrs(&self) -> &[syn::Attribute] {
+                &self.attrs
+            }
+        }
+    };
+}
+
+impl_syn_item_helper!(syn::ItemExternCrate);
+impl_syn_item_helper!(syn::ItemUse);
+impl_syn_item_helper!(syn::ItemStatic);
+impl_syn_item_helper!(syn::ItemConst);
+impl_syn_item_helper!(syn::ItemFn);
+impl_syn_item_helper!(syn::ImplItemMethod);
+impl_syn_item_helper!(syn::ItemMod);
+impl_syn_item_helper!(syn::ItemForeignMod);
+impl_syn_item_helper!(syn::ItemType);
+impl_syn_item_helper!(syn::ItemStruct);
+impl_syn_item_helper!(syn::ItemEnum);
+impl_syn_item_helper!(syn::ItemUnion);
+impl_syn_item_helper!(syn::ItemTrait);
+impl_syn_item_helper!(syn::ItemImpl);
+impl_syn_item_helper!(syn::ItemMacro);
+impl_syn_item_helper!(syn::ItemMacro2);
+impl_syn_item_helper!(syn::ItemTraitAlias);
+
+/// Helper function for accessing Abi information
+pub trait SynAbiHelpers {
+    fn is_c(&self) -> bool;
+    fn is_omitted(&self) -> bool;
+}
+
+impl SynAbiHelpers for Option<syn::Abi> {
+    fn is_c(&self) -> bool {
+        if let Some(ref abi) = *self {
+            if let Some(ref lit_string) = abi.name {
+                return matches!(lit_string.value().as_str(), "C" | "C-unwind");
+            }
+        }
+        false
+    }
+    fn is_omitted(&self) -> bool {
+        if let Some(ref abi) = *self {
+            abi.name.is_none()
+        } else {
+            false
+        }
+    }
+}
+
+impl SynAbiHelpers for syn::Abi {
+    fn is_c(&self) -> bool {
+        if let Some(ref lit_string) = self.name {
+            matches!(lit_string.value().as_str(), "C" | "C-unwind")
+        } else {
+            false
+        }
+    }
+    fn is_omitted(&self) -> bool {
+        self.name.is_none()
+    }
+}
+
+impl SynAttributeHelpers for [syn::Attribute] {
+    fn attrs(&self) -> &[syn::Attribute] {
+        self
+    }
+}
+
+fn split_doc_attr(input: &str) -> Vec<String> {
+    input
+        // Convert two newline (indicate "new paragraph") into two line break.
+        .replace("\n\n", "  \n  \n")
+        // Convert newline after two spaces (indicate "line break") into line break.
+        .split("  \n")
+        // Convert single newline (indicate hard-wrapped) into space.
+        .map(|s| s.replace('\n', " "))
+        .map(|s| s.trim_end().to_string())
+        .collect()
+}
diff --git a/src/bindgen/writer.rs b/src/bindgen/writer.rs
new file mode 100644
index 0000000..eed6917
--- /dev/null
+++ b/src/bindgen/writer.rs
@@ -0,0 +1,258 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::cmp;
+use std::io;
+use std::io::Write;
+
+use crate::bindgen::config::{Braces, Config, Language};
+use crate::bindgen::Bindings;
+
+/// A type of way to format a list.
+pub enum ListType<'a> {
+    /// Join each adjacent item with a str.
+    Join(&'a str),
+    /// End each item with a str.
+    Cap(&'a str),
+}
+
+/// A utility wrapper to write unbuffered data and correctly adjust positions.
+struct InnerWriter<'a, 'b: 'a, F: 'a + Write>(&'a mut SourceWriter<'b, F>);
+
+impl<'a, 'b, F: Write> Write for InnerWriter<'a, 'b, F> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let writer = &mut self.0;
+
+        if !writer.line_started {
+            for _ in 0..writer.spaces() {
+                write!(writer.out, " ").unwrap();
+            }
+            writer.line_started = true;
+            writer.line_length += writer.spaces();
+        }
+
+        let written = writer.out.write(buf)?;
+        writer.line_length += written;
+        writer.max_line_length = cmp::max(writer.max_line_length, writer.line_length);
+        Ok(written)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.0.out.flush()
+    }
+}
+
+/// A utility writer for generating code easier.
+pub struct SourceWriter<'a, F: Write> {
+    out: F,
+    bindings: &'a Bindings,
+    spaces: Vec<usize>,
+    line_started: bool,
+    line_length: usize,
+    line_number: usize,
+    max_line_length: usize,
+}
+
+pub type MeasureWriter<'a> = SourceWriter<'a, &'a mut Vec<u8>>;
+
+impl<'a, F: Write> SourceWriter<'a, F> {
+    pub fn new(out: F, bindings: &'a Bindings) -> Self {
+        SourceWriter {
+            out,
+            bindings,
+            spaces: vec![0],
+            line_started: false,
+            line_length: 0,
+            line_number: 1,
+            max_line_length: 0,
+        }
+    }
+
+    pub fn bindings(&self) -> &Bindings {
+        self.bindings
+    }
+
+    /// Takes a function that writes source and returns the maximum line length
+    /// written.
+    pub fn try_write<T>(&mut self, func: T, max_line_length: usize) -> bool
+    where
+        T: Fn(&mut MeasureWriter),
+    {
+        if self.line_length > max_line_length {
+            return false;
+        }
+
+        let mut buffer = Vec::new();
+        let line_length = {
+            let mut measurer = SourceWriter {
+                out: &mut buffer,
+                bindings: self.bindings,
+                spaces: self.spaces.clone(),
+                line_started: self.line_started,
+                line_length: self.line_length,
+                line_number: self.line_number,
+                max_line_length: self.line_length,
+            };
+
+            func(&mut measurer);
+
+            measurer.max_line_length
+        };
+
+        if line_length > max_line_length {
+            return false;
+        }
+        // We don't want the extra alignment, it's already accounted for by the
+        // measurer.
+        self.line_started = true;
+        InnerWriter(self).write_all(&buffer).unwrap();
+        true
+    }
+
+    fn spaces(&self) -> usize {
+        *self.spaces.last().unwrap()
+    }
+
+    pub fn push_set_spaces(&mut self, spaces: usize) {
+        self.spaces.push(spaces);
+    }
+
+    pub fn pop_set_spaces(&mut self) {
+        self.pop_tab()
+    }
+
+    pub fn line_length_for_align(&self) -> usize {
+        if self.line_started {
+            self.line_length
+        } else {
+            self.line_length + self.spaces()
+        }
+    }
+
+    pub fn push_tab(&mut self) {
+        let spaces = self.spaces() - (self.spaces() % self.bindings.config.tab_width)
+            + self.bindings.config.tab_width;
+        self.spaces.push(spaces);
+    }
+
+    pub fn pop_tab(&mut self) {
+        assert!(!self.spaces.is_empty());
+        self.spaces.pop();
+    }
+
+    pub fn new_line(&mut self) {
+        self.out
+            .write_all(self.bindings.config.line_endings.as_str().as_bytes())
+            .unwrap();
+        self.line_started = false;
+        self.line_length = 0;
+        self.line_number += 1;
+    }
+
+    pub fn new_line_if_not_start(&mut self) {
+        if self.line_number != 1 {
+            self.new_line();
+        }
+    }
+
+    pub fn open_brace(&mut self) {
+        match self.bindings.config.language {
+            Language::Cxx | Language::C => match self.bindings.config.braces {
+                Braces::SameLine => {
+                    self.write(" {");
+                    self.push_tab();
+                    self.new_line();
+                }
+                Braces::NextLine => {
+                    self.new_line();
+                    self.write("{");
+                    self.push_tab();
+                    self.new_line();
+                }
+            },
+            Language::Cython => {
+                self.write(":");
+                self.new_line();
+                self.push_tab();
+            }
+        }
+    }
+
+    pub fn close_brace(&mut self, semicolon: bool) {
+        self.pop_tab();
+        match self.bindings.config.language {
+            Language::Cxx | Language::C => {
+                self.new_line();
+                if semicolon {
+                    self.write("};");
+                } else {
+                    self.write("}");
+                }
+            }
+            Language::Cython => {}
+        }
+    }
+
+    pub fn write(&mut self, text: &'static str) {
+        write!(self, "{}", text);
+    }
+
+    pub fn write_raw_block(&mut self, block: &str) {
+        self.line_started = true;
+        write!(self, "{}", block);
+    }
+
+    pub fn write_fmt(&mut self, fmt: ::std::fmt::Arguments) {
+        InnerWriter(self).write_fmt(fmt).unwrap();
+    }
+
+    pub fn write_horizontal_source_list<S: Source>(
+        &mut self,
+        items: &[S],
+        list_type: ListType<'_>,
+    ) {
+        for (i, item) in items.iter().enumerate() {
+            item.write(&self.bindings.config, self);
+
+            match list_type {
+                ListType::Join(text) => {
+                    if i != items.len() - 1 {
+                        write!(self, "{}", text);
+                    }
+                }
+                ListType::Cap(text) => {
+                    write!(self, "{}", text);
+                }
+            }
+        }
+    }
+
+    pub fn write_vertical_source_list<S: Source>(&mut self, items: &[S], list_type: ListType<'_>) {
+        let align_length = self.line_length_for_align();
+        self.push_set_spaces(align_length);
+        for (i, item) in items.iter().enumerate() {
+            item.write(&self.bindings.config, self);
+
+            match list_type {
+                ListType::Join(text) => {
+                    if i != items.len() - 1 {
+                        write!(self, "{}", text);
+                    }
+                }
+                ListType::Cap(text) => {
+                    write!(self, "{}", text);
+                }
+            }
+
+            if i != items.len() - 1 {
+                self.new_line();
+            }
+        }
+        self.pop_tab();
+    }
+}
+
+pub trait Source {
+    fn write<F: Write>(&self, config: &Config, _: &mut SourceWriter<F>);
+}