Added Categories to objective-c inheritance.

* Added items_mut to BindgenContext
* Added Clone to ObjCInterface, ObjCMethod and FunctionSig :/
* Added references to the ObjCInterfaces for categories that extend a
given ObjCInterface

Author: simlay

src/codegen/mod.rs

@@ -3821,6 +3821,26 @@ impl CodeGenerator for ObjCInterface {
                         }
                     };
                     result.push(impl_trait);
+                    for category in &parent.categories {
+                        let category_name =
+                            ctx.rust_ident(category.rust_name());
+                        let impl_trait = if category.is_template() {
+                            let template_names: Vec<Ident> = parent
+                                .template_names
+                                .iter()
+                                .map(|g| ctx.rust_ident(g))
+                                .collect();
+                            quote! {
+                                impl <#(#template_names :'static),*> #category_name <#(#template_names),*> for #class_name {
+                                }
+                            }
+                        } else {
+                            quote! {
+                                impl #category_name for #class_name { }
+                            }
+                        };
+                        result.push(impl_trait);
+                    }
                     parent.parent_class
                 } else {
                     None

src/ir/context.rs

@@ -902,6 +902,17 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         })
     }
 
+    /// IterMut over all items that have been defined.
+    pub fn items_mut(&mut self) -> impl Iterator<Item = (ItemId, &mut Item)> {
+        self.items
+            .iter_mut()
+            .enumerate()
+            .filter_map(|(index, item)| {
+                let item = item.as_mut()?;
+                Some((ItemId(index), item))
+            })
+    }
+
     /// Have we collected all unresolved type references yet?
     pub fn collected_typerefs(&self) -> bool {
         self.collected_typerefs

src/ir/function.rs

@@ -210,7 +210,7 @@ impl quote::ToTokens for Abi {
 }
 
 /// A function signature.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FunctionSig {
     /// The return type of the function.
     return_type: TypeId,

src/ir/objc.rs

@@ -21,7 +21,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 /// Objective C interface as used in TypeKind
 ///
 /// Also protocols and categories are parsed as this type
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ObjCInterface {
     /// The name
     /// like, NSObject
@@ -37,6 +37,9 @@ pub struct ObjCInterface {
     /// The list of protocols that this interface conforms to.
     pub conforms_to: Vec<ItemId>,
 
+    /// The list of categories that this interface is extended by.
+    pub categories: Vec<ObjCInterface>,
+
     /// The direct parent for this interface.
     pub parent_class: Option<ItemId>,
 
@@ -47,7 +50,7 @@ pub struct ObjCInterface {
 }
 
 /// The objective c methods
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ObjCMethod {
     /// The original method selector name
     /// like, dataWithBytes:length:
@@ -68,6 +71,7 @@ impl ObjCInterface {
         ObjCInterface {
             name: name.to_owned(),
             category: None,
+            categories: Vec::new(),
             is_protocol: false,
             template_names: Vec::new(),
             parent_class: None,
@@ -140,9 +144,11 @@ impl ObjCInterface {
                 CXCursor_ObjCClassRef => {
                     if cursor.kind() == CXCursor_ObjCCategoryDecl {
                         // We are actually a category extension, and we found the reference
-                        // to the original interface, so name this interface approriately
+                        // to the original interface, so name this interface approriately.
+
                         interface.name = c.spelling();
                         interface.category = Some(cursor.spelling());
+
                     }
                 }
                 CXCursor_ObjCProtocolRef => {
@@ -194,6 +200,39 @@ impl ObjCInterface {
             }
             CXChildVisit_Continue
         });
+
+        if interface.is_category() {
+            // If this interface is a category, we need to find the interface that this category
+            // extends.
+            let needle = format!("{}", interface.name());
+            debug!(
+                "Category {} belongs to {}, find the item",
+                interface.rust_name(),
+                needle
+            );
+            for (_, item) in ctx.items_mut() {
+                if let Some(ref mut ty) = item.kind_mut().as_type_mut() {
+                    match ty.kind_mut() {
+                        TypeKind::ObjCInterface(ref mut real_interface) => {
+                            if !real_interface.is_category() {
+                                debug!("Checking interface {}, against needle {:?}", real_interface.name, needle);
+                                if needle == real_interface.name() {
+                                    debug!(
+                                        "Found real interface {:?}",
+                                        real_interface
+                                    );
+                                    real_interface
+                                        .categories
+                                        .push(interface.clone());
+                                    break;
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
         Some(interface)
     }
 

src/ir/ty.rs

@@ -627,7 +627,7 @@ pub enum TypeKind {
     /// A compound type, that is, a class, struct, or union.
     Comp(CompInfo),
 
-    /// An opaque type that we just don't understand. All usage of this shoulf
+    /// An opaque type that we just don't understand. All usage of this should
     /// result in an opaque blob of bytes generated from the containing type's
     /// layout.
     Opaque,

tests/expectations/tests/objc_category_inheritance.rs

@@ -0,0 +1,66 @@
+/* automatically generated by rust-bindgen */
+
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+#[macro_use]
+extern crate objc;
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Clone, Copy)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn method(self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(self, method)
+    }
+}
+impl Foo_BarCategory for Foo {}
+pub trait Foo_BarCategory: Sized + std::ops::Deref {
+    unsafe fn categoryMethod(self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(self, categoryMethod)
+    }
+}
+#[repr(transparent)]
+#[derive(Clone, Copy)]
+pub struct Bar(pub id);
+impl std::ops::Deref for Bar {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Bar {}
+impl Bar {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(objc::class!(Bar), alloc) })
+    }
+}
+impl IFoo for Bar {}
+impl Foo_BarCategory for Bar {}
+impl IBar for Bar {}
+pub trait IBar: Sized + std::ops::Deref {}

tests/headers/objc_category_inheritance.h

@@ -0,0 +1,13 @@
+// bindgen-flags: --objc-extern-crate -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
+-(void)method;
+@end
+
+@interface Foo (BarCategory)
+-(void)categoryMethod;
+@end
+
+@interface Bar: Foo
+@end