Rewrite the core of the binding generator.

TL;DR: The binding generator is a mess as of right now. At first it was funny
(in a "this is challenging" sense) to improve on it, but this is not
sustainable.

The truth is that the current architecture of the binding generator is a huge
pile of hacks, so these few days I've been working on rewriting it with a few
goals.

 1) Have the hacks as contained and identified as possible. They're sometimes
    needed because how clang exposes the AST, but ideally those hacks are well
    identified and don't interact randomly with each others.

    As an example, in the current bindgen when scanning the parameters of a
    function that references a struct clones all the struct information, then if
    the struct name changes (because we mangle it), everything breaks.

 2) Support extending the bindgen output without having to deal with clang. The
    way I'm aiming to do this is separating completely the parsing stage from
    the code generation one, and providing a single id for each item the binding
    generator provides.

 3) No more random mutation of the internal representation from anywhere. That
    means no more Rc<RefCell<T>>, no more random circular references, no more
    borrow_state... nothing.

 4) No more deduplication of declarations before code generation.

    Current bindgen has a stage, called `tag_dup_decl`[1], that takes care of
    deduplicating declarations. That's completely buggy, and for C++ it's a
    complete mess, since we YOLO modify the world.

    I've managed to take rid of this using the clang canonical declaration, and
    the definition, to avoid scanning any type/item twice.

 5) Code generation should not modify any internal data structure. It can lookup
    things, traverse whatever it needs, but not modifying randomly.

 6) Each item should have a canonical name, and a single source of mangling
    logic, and that should be computed from the inmutable state, at code
    generation.

    I've put a few canonical_name stuff in the code generation phase, but it's
    still not complete, and should change if I implement namespaces.

Improvements pending until this can land:

 1) Add support for missing core stuff, mainly generating functions (note that
    we parse the signatures for types correctly though), bitfields, generating
    C++ methods.

 2) Add support for the necessary features that were added to work around some
    C++ pitfalls, like opaque types, etc...

 3) Add support for the sugar that Manish added recently.

 4) Optionally (and I guess this can land without it, because basically nobody
    uses it since it's so buggy), bring back namespace support.

These are not completely trivial, but I think I can do them quite easily with
the current architecture.

I'm putting the current state of affairs here as a request for comments... Any
thoughts? Note that there are still a few smells I want to eventually
re-redesign, like the ParseError::Recurse thing, but until that happens I'm
way happier with this kind of architecture.

I'm keeping the old `parser.rs` and `gen.rs` in tree just for reference while I
code, but they will go away.

[1]: https://github.com/Yamakaky/rust-bindgen/blob/master/src/gen.rs#L448

1 files changed, 0 insertions, 464 deletions

diff --git a/src/hacks/refcell.rs b/src/hacks/refcell.rs
deleted file mode 100644
index 408e95d4..00000000
--- a/src/hacks/refcell.rs
+++ /dev/null
@@ -1,464 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers.
-// See http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A fork of std::cell::RefCell that makes `as_unsafe_cell` usable on stable Rust.
-//!
-//! FIXME(https://github.com/rust-lang/rust/issues/27708): Remove this
-//! (revert commit f7f81e0ed0b62402db291e28a9bb16f7194ebf78 / PR #11835)
-//! when `std::cell::RefCell::as_unsafe_cell` is in Rust’s stable channel.
-
-#![allow(unsafe_code, dead_code)]
-
-use std::cell::{UnsafeCell, Cell};
-use std::cmp::Ordering;
-use std::ops::{Deref, DerefMut};
-
-/// A fork of std::cell::RefCell that makes `as_unsafe_cell` usable on stable Rust.
-///
-/// FIXME(https://github.com/rust-lang/rust/issues/27708): Remove this
-/// (revert commit f7f81e0ed0b62402db291e28a9bb16f7194ebf78 / PR #11835)
-/// when `std::cell::RefCell::as_unsafe_cell` is in Rust’s stable channel.
-#[derive(Debug)]
-pub struct RefCell<T: ?Sized> {
-    borrow: Cell<BorrowFlag>,
-    value: UnsafeCell<T>,
-}
-type BorrowFlag = usize;
-
-/// An enumeration of values returned from the `state` method on a `RefCell<T>`.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum BorrowState {
-    /// The cell is currently being read, there is at least one active `borrow`.
-    Reading,
-    /// The cell is currently being written to, there is an active `borrow_mut`.
-    Writing,
-    /// There are no outstanding borrows on this cell.
-    Unused,
-}
-
-// Values [1, MAX-1] represent the number of `Ref` active
-// (will not outgrow its range since `usize` is the size of the address space)
-const UNUSED: BorrowFlag = 0;
-const WRITING: BorrowFlag = !0;
-
-impl<T> RefCell<T> {
-    /// Creates a new `RefCell` containing `value`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::cell::RefCell;
-    ///
-    /// let c = RefCell::new(5);
-    /// ```
-    #[inline]
-    pub fn new(value: T) -> RefCell<T> {
-        RefCell {
-            value: UnsafeCell::new(value),
-            borrow: Cell::new(UNUSED),
-        }
-    }
-
-    /// Consumes the `RefCell`, returning the wrapped value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::cell::RefCell;
-    ///
-    /// let c = RefCell::new(5);
-    ///
-    /// let five = c.into_inner();
-    /// ```
-    #[inline]
-    pub fn into_inner(self) -> T {
-        // Since this function takes `self` (the `RefCell`) by value, the
-        // compiler statically verifies that it is not currently borrowed.
-        // Therefore the following assertion is just a `debug_assert!`.
-        debug_assert!(self.borrow.get() == UNUSED);
-        unsafe { self.value.into_inner() }
-    }
-}
-
-impl<T: ?Sized> RefCell<T> {
-    /// Query the current state of this `RefCell`
-    ///
-    /// The returned value can be dispatched on to determine if a call to
-    /// `borrow` or `borrow_mut` would succeed.
-    #[inline]
-    pub fn borrow_state(&self) -> BorrowState {
-        match self.borrow.get() {
-            WRITING => BorrowState::Writing,
-            UNUSED => BorrowState::Unused,
-            _ => BorrowState::Reading,
-        }
-    }
-
-    /// Immutably borrows the wrapped value.
-    ///
-    /// The borrow lasts until the returned `Ref` exits scope. Multiple
-    /// immutable borrows can be taken out at the same time.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value is currently mutably borrowed.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::cell::RefCell;
-    ///
-    /// let c = RefCell::new(5);
-    ///
-    /// let borrowed_five = c.borrow();
-    /// let borrowed_five2 = c.borrow();
-    /// ```
-    ///
-    /// An example of panic:
-    ///
-    /// ```
-    /// use std::cell::RefCell;
-    /// use std::thread;
-    ///
-    /// let result = thread::spawn(move || {
-    ///    let c = RefCell::new(5);
-    ///    let m = c.borrow_mut();
-    ///
-    ///    let b = c.borrow(); // this causes a panic
-    /// }).join();
-    ///
-    /// assert!(result.is_err());
-    /// ```
-    #[inline]
-    pub fn borrow(&self) -> Ref<T> {
-        match BorrowRef::new(&self.borrow) {
-            Some(b) => Ref {
-                value: unsafe { &*self.value.get() },
-                borrow: b,
-            },
-            None => panic!("RefCell<T> already mutably borrowed"),
-        }
-    }
-
-    /// Mutably borrows the wrapped value.
-    ///
-    /// The borrow lasts until the returned `RefMut` exits scope. The value
-    /// cannot be borrowed while this borrow is active.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value is currently borrowed.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::cell::RefCell;
-    ///
-    /// let c = RefCell::new(5);
-    ///
-    /// *c.borrow_mut() = 7;
-    ///
-    /// assert_eq!(*c.borrow(), 7);
-    /// ```
-    ///
-    /// An example of panic:
-    ///
-    /// ```
-    /// use std::cell::RefCell;
-    /// use std::thread;
-    ///
-    /// let result = thread::spawn(move || {
-    ///    let c = RefCell::new(5);
-    ///    let m = c.borrow();
-    ///
-    ///    let b = c.borrow_mut(); // this causes a panic
-    /// }).join();
-    ///
-    /// assert!(result.is_err());
-    /// ```
-    #[inline]
-    pub fn borrow_mut(&self) -> RefMut<T> {
-        match BorrowRefMut::new(&self.borrow) {
-            Some(b) => RefMut {
-                value: unsafe { &mut *self.value.get() },
-                borrow: b,
-            },
-            None => panic!("RefCell<T> already borrowed"),
-        }
-    }
-
-    /// Returns a reference to the underlying `UnsafeCell`.
-    ///
-    /// This can be used to circumvent `RefCell`'s safety checks.
-    ///
-    /// This function is `unsafe` because `UnsafeCell`'s field is public.
-    #[inline]
-    pub unsafe fn as_unsafe_cell(&self) -> &UnsafeCell<T> {
-        &self.value
-    }
-
-    /// Returns a mutable reference to the underlying data.
-    ///
-    /// This call borrows `RefCell` mutably (at compile-time) so there is no
-    /// need for dynamic checks.
-    #[inline]
-    pub fn get_mut(&mut self) -> &mut T {
-        unsafe {
-            &mut *self.value.get()
-        }
-    }
-}
-
-unsafe impl<T: ?Sized> Send for RefCell<T> where T: Send {}
-
-impl<T: Clone> Clone for RefCell<T> {
-    #[inline]
-    fn clone(&self) -> RefCell<T> {
-        RefCell::new(self.borrow().clone())
-    }
-}
-
-impl<T: Default> Default for RefCell<T> {
-    #[inline]
-    fn default() -> RefCell<T> {
-        RefCell::new(Default::default())
-    }
-}
-
-impl<T: ?Sized + PartialEq> PartialEq for RefCell<T> {
-    #[inline]
-    fn eq(&self, other: &RefCell<T>) -> bool {
-        *self.borrow() == *other.borrow()
-    }
-}
-
-impl<T: ?Sized + Eq> Eq for RefCell<T> {}
-
-impl<T: ?Sized + PartialOrd> PartialOrd for RefCell<T> {
-    #[inline]
-    fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering> {
-        self.borrow().partial_cmp(&*other.borrow())
-    }
-
-    #[inline]
-    fn lt(&self, other: &RefCell<T>) -> bool {
-        *self.borrow() < *other.borrow()
-    }
-
-    #[inline]
-    fn le(&self, other: &RefCell<T>) -> bool {
-        *self.borrow() <= *other.borrow()
-    }
-
-    #[inline]
-    fn gt(&self, other: &RefCell<T>) -> bool {
-        *self.borrow() > *other.borrow()
-    }
-
-    #[inline]
-    fn ge(&self, other: &RefCell<T>) -> bool {
-        *self.borrow() >= *other.borrow()
-    }
-}
-
-impl<T: ?Sized + Ord> Ord for RefCell<T> {
-    #[inline]
-    fn cmp(&self, other: &RefCell<T>) -> Ordering {
-        self.borrow().cmp(&*other.borrow())
-    }
-}
-
-struct BorrowRef<'b> {
-    borrow: &'b Cell<BorrowFlag>,
-}
-
-impl<'b> BorrowRef<'b> {
-    #[inline]
-    fn new(borrow: &'b Cell<BorrowFlag>) -> Option<BorrowRef<'b>> {
-        match borrow.get() {
-            WRITING => None,
-            b => {
-                borrow.set(b + 1);
-                Some(BorrowRef { borrow: borrow })
-            },
-        }
-    }
-}
-
-impl<'b> Drop for BorrowRef<'b> {
-    #[inline]
-    fn drop(&mut self) {
-        let borrow = self.borrow.get();
-        debug_assert!(borrow != WRITING && borrow != UNUSED);
-        self.borrow.set(borrow - 1);
-    }
-}
-
-impl<'b> Clone for BorrowRef<'b> {
-    #[inline]
-    fn clone(&self) -> BorrowRef<'b> {
-        // Since this Ref exists, we know the borrow flag
-        // is not set to WRITING.
-        let borrow = self.borrow.get();
-        debug_assert!(borrow != UNUSED);
-        // Prevent the borrow counter from overflowing.
-        assert!(borrow != WRITING);
-        self.borrow.set(borrow + 1);
-        BorrowRef { borrow: self.borrow }
-    }
-}
-
-/// Wraps a borrowed reference to a value in a `RefCell` box.
-/// A wrapper type for an immutably borrowed value from a `RefCell<T>`.
-///
-/// See the [module-level documentation](index.html) for more.
-pub struct Ref<'b, T: ?Sized + 'b> {
-    value: &'b T,
-    borrow: BorrowRef<'b>,
-}
-
-impl<'b, T: ?Sized> Deref for Ref<'b, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        self.value
-    }
-}
-
-impl<'b, T: ?Sized> Ref<'b, T> {
-    /// Copies a `Ref`.
-    ///
-    /// The `RefCell` is already immutably borrowed, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `Ref::clone(...)`.  A `Clone` implementation or a method would interfere
-    /// with the widespread use of `r.borrow().clone()` to clone the contents of
-    /// a `RefCell`.
-    #[inline]
-    pub fn clone(orig: &Ref<'b, T>) -> Ref<'b, T> {
-        Ref {
-            value: orig.value,
-            borrow: orig.borrow.clone(),
-        }
-    }
-
-    /// Make a new `Ref` for a component of the borrowed data.
-    ///
-    /// The `RefCell` is already immutably borrowed, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as `Ref::map(...)`.
-    /// A method would interfere with methods of the same name on the contents
-    /// of a `RefCell` used through `Deref`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::cell::{RefCell, Ref};
-    ///
-    /// let c = RefCell::new((5, 'b'));
-    /// let b1: Ref<(u32, char)> = c.borrow();
-    /// let b2: Ref<u32> = Ref::map(b1, |t| &t.0);
-    /// assert_eq!(*b2, 5)
-    /// ```
-    #[inline]
-    pub fn map<U: ?Sized, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, U>
-        where F: FnOnce(&T) -> &U
-    {
-        Ref {
-            value: f(orig.value),
-            borrow: orig.borrow,
-        }
-    }
-}
-
-impl<'b, T: ?Sized> RefMut<'b, T> {
-    /// Make a new `RefMut` for a component of the borrowed data, e.g. an enum
-    /// variant.
-    ///
-    /// The `RefCell` is already mutably borrowed, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `RefMut::map(...)`.  A method would interfere with methods of the same
-    /// name on the contents of a `RefCell` used through `Deref`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::cell::{RefCell, RefMut};
-    ///
-    /// let c = RefCell::new((5, 'b'));
-    /// {
-    ///     let b1: RefMut<(u32, char)> = c.borrow_mut();
-    ///     let mut b2: RefMut<u32> = RefMut::map(b1, |t| &mut t.0);
-    ///     assert_eq!(*b2, 5);
-    ///     *b2 = 42;
-    /// }
-    /// assert_eq!(*c.borrow(), (42, 'b'));
-    /// ```
-    #[inline]
-    pub fn map<U: ?Sized, F>(orig: RefMut<'b, T>, f: F) -> RefMut<'b, U>
-        where F: FnOnce(&mut T) -> &mut U
-    {
-        RefMut {
-            value: f(orig.value),
-            borrow: orig.borrow,
-        }
-    }
-}
-
-struct BorrowRefMut<'b> {
-    borrow: &'b Cell<BorrowFlag>,
-}
-
-impl<'b> Drop for BorrowRefMut<'b> {
-    #[inline]
-    fn drop(&mut self) {
-        let borrow = self.borrow.get();
-        debug_assert!(borrow == WRITING);
-        self.borrow.set(UNUSED);
-    }
-}
-
-impl<'b> BorrowRefMut<'b> {
-    #[inline]
-    fn new(borrow: &'b Cell<BorrowFlag>) -> Option<BorrowRefMut<'b>> {
-        match borrow.get() {
-            UNUSED => {
-                borrow.set(WRITING);
-                Some(BorrowRefMut { borrow: borrow })
-            },
-            _ => None,
-        }
-    }
-}
-
-/// A wrapper type for a mutably borrowed value from a `RefCell<T>`.
-///
-/// See the [module-level documentation](index.html) for more.
-pub struct RefMut<'b, T: ?Sized + 'b> {
-    value: &'b mut T,
-    borrow: BorrowRefMut<'b>,
-}
-
-impl<'b, T: ?Sized> Deref for RefMut<'b, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        self.value
-    }
-}
-
-impl<'b, T: ?Sized> DerefMut for RefMut<'b, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut T {
-        self.value
-    }
-}