Add initial Objective C support

It parses interfaces and protocol but ignores base classes, and their methods which don’t have arguments, the method signature is currently ignored.
Also you can pass objc class instances to C functions.

Next steps are inheritance/base classes, method signatures, properties, categories.
Then check with system headers what is missing.

Author: scoopr

src/clang.rs

@@ -688,7 +688,8 @@ impl Type {
             CXType_Pointer |
             CXType_RValueReference |
             CXType_LValueReference |
-            CXType_MemberPointer => {
+            CXType_MemberPointer |
+            CXType_ObjCObjectPointer => {
                 let ret = Type {
                     x: unsafe { clang_getPointeeType(self.x) },
                 };

src/codegen/mod.rs

@@ -13,6 +13,7 @@ use ir::item::{Item, ItemAncestors, ItemCanonicalName, ItemCanonicalPath};
 use ir::item_kind::ItemKind;
 use ir::layout::Layout;
 use ir::module::Module;
+use ir::objc::ObjCInterface;
 use ir::ty::{Type, TypeKind};
 use ir::type_collector::ItemSet;
 use ir::var::Var;
@@ -84,6 +85,8 @@ struct CodegenResult<'a> {
     /// Whether an union has been generated at least once.
     saw_union: bool,
 
+    saw_objc: bool,
+
     items_seen: HashSet<ItemId>,
     /// The set of generated function/var names, needed because in C/C++ is
     /// legal to do something like:
@@ -115,6 +118,7 @@ impl<'a> CodegenResult<'a> {
         CodegenResult {
             items: vec![],
             saw_union: false,
+            saw_objc: false,
             codegen_id: codegen_id,
             items_seen: Default::default(),
             functions_seen: Default::default(),
@@ -132,6 +136,10 @@ impl<'a> CodegenResult<'a> {
         self.saw_union = true;
     }
 
+    fn saw_objc(&mut self) {
+        self.saw_objc = true;
+    }
+
     fn seen(&self, item: ItemId) -> bool {
         self.items_seen.contains(&item)
     }
@@ -175,6 +183,7 @@ impl<'a> CodegenResult<'a> {
         cb(&mut new);
 
         self.saw_union |= new.saw_union;
+        self.saw_objc |= new.saw_objc;
 
         new.items
     }
@@ -347,6 +356,9 @@ impl CodeGenerator for Module {
                 if ctx.need_bindegen_complex_type() {
                     utils::prepend_complex_type(ctx, &mut *result);
                 }
+                if result.saw_objc {
+                    utils::prepend_objc_header(ctx, &mut *result);
+                }
             }
         };
 
@@ -591,6 +603,9 @@ impl CodeGenerator for Type {
             TypeKind::Enum(ref ei) => {
                 ei.codegen(ctx, result, whitelisted_items, item)
             }
+            TypeKind::ObjCInterface(ref interface) => {
+                interface.codegen(ctx, result, whitelisted_items, item)
+            }
             ref u @ TypeKind::UnresolvedTypeRef(..) => {
                 unreachable!("Should have been resolved after parsing {:?}!", u)
             }
@@ -2068,6 +2083,10 @@ impl ToRustTy for Type {
                 let ident = ctx.rust_ident(&name);
                 quote_ty!(ctx.ext_cx(), $ident)
             }
+            TypeKind::ObjCInterface(..) => {
+                let ident = ctx.rust_ident("id");
+                quote_ty!(ctx.ext_cx(), $ident)
+            }
             ref u @ TypeKind::UnresolvedTypeRef(..) => {
                 unreachable!("Should have been resolved after parsing {:?}!", u)
             }
@@ -2101,10 +2120,24 @@ impl ToRustTy for FunctionSig {
             //     the array type derivation.
             //
             // [1]: http://c0x.coding-guidelines.com/6.7.5.3.html
-            let arg_ty = if let TypeKind::Array(t, _) = *arg_ty.canonical_type(ctx).kind() {
+
+
+            let arg_ty = match *arg_ty.canonical_type(ctx).kind() {
+                TypeKind::Array(t, _) => {
                 t.to_rust_ty(ctx).to_ptr(arg_ty.is_const(), ctx.span())
+                },
+                TypeKind::Pointer(inner) => {
+                    let inner = ctx.resolve_item(inner);
+                    let inner_ty = inner.expect_type();
+                    if let TypeKind::ObjCInterface(_) = *inner_ty.canonical_type(ctx).kind() {
+                        aster::ty::TyBuilder::new().id("id")
             } else {
                 arg_item.to_rust_ty(ctx)
+                    }
+                },
+                _ => {
+                    arg_item.to_rust_ty(ctx)
+                }
             };
 
             let arg_name = match *name {
@@ -2220,6 +2253,90 @@ impl CodeGenerator for Function {
     }
 }
 
+impl CodeGenerator for ObjCInterface {
+    type Extra = Item;
+    fn codegen<'a>(&self,
+                   ctx: &BindgenContext,
+                   result: &mut CodegenResult<'a>,
+                   _whitelisted_items: &ItemSet,
+                   _: &Item) {
+
+        let mut impl_items = vec![];
+        let mut trait_items = vec![];
+
+        for method in &self.methods {
+            let method_name = ctx.rust_ident(&method.name);
+
+            let body = quote_stmt!(ctx.ext_cx(), msg_send![self, $method_name])
+                .unwrap();
+            let block = ast::Block {
+                stmts: vec![body],
+                id: ast::DUMMY_NODE_ID,
+                rules: ast::BlockCheckMode::Default,
+                span: ctx.span(),
+            };
+
+            let sig = aster::AstBuilder::new()
+                .method_sig()
+                .unsafe_()
+                .fn_decl()
+                .self_()
+                .build(ast::SelfKind::Value(ast::Mutability::Immutable))//ast::SelfKind::Region(None, ast::Mutability::Mutable))
+                .build(ast::FunctionRetTy::Default(ctx.span()));
+            let attrs = vec![];
+
+            let impl_item = ast::ImplItem {
+                id: ast::DUMMY_NODE_ID,
+                ident: ctx.rust_ident(&method.rust_name),
+                vis: ast::Visibility::Inherited, // Public,
+                attrs: attrs.clone(),
+                node: ast::ImplItemKind::Method(sig.clone(), P(block)),
+                defaultness: ast::Defaultness::Final,
+                span: ctx.span(),
+            };
+
+            let trait_item = ast::TraitItem {
+                id: ast::DUMMY_NODE_ID,
+                ident: ctx.rust_ident(&method.rust_name),
+                attrs: attrs,
+                node: ast::TraitItemKind::Method(sig, None),
+                span: ctx.span(),
+            };
+
+            impl_items.push(impl_item);
+            trait_items.push(trait_item)
+        }
+
+
+        let trait_block = aster::AstBuilder::new()
+            .item()
+            .pub_()
+            .trait_(&self.name)
+            .with_items(trait_items)
+            .build();
+
+        let ty_for_impl = aster::AstBuilder::new()
+            .ty()
+            .path()
+            .id(ctx.rust_ident("id"))
+            .build();
+        let impl_block = aster::AstBuilder::new()
+            .item()
+            .impl_()
+            .trait_()
+            .id(&self.name)
+            .build()
+            .with_items(impl_items)
+            .build_ty(ty_for_impl);
+
+        result.push(trait_block);
+        result.push(impl_block);
+        result.saw_objc();
+    }
+}
+
+
+
 pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
     context.gen(|context| {
         let counter = Cell::new(0);
@@ -2253,6 +2370,25 @@ mod utils {
     use syntax::ast;
     use syntax::ptr::P;
 
+
+    pub fn prepend_objc_header(ctx: &BindgenContext,
+                               result: &mut Vec<P<ast::Item>>) {
+
+        let use_objc = quote_item!(ctx.ext_cx(),
+            use objc;
+        )
+            .unwrap();
+        let id_type = quote_item!(ctx.ext_cx(),
+            #[allow(non_camel_case_types)]
+            pub type id = *mut objc::runtime::Object;
+        )
+            .unwrap();
+
+        let items = vec![use_objc, id_type];
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+
     pub fn prepend_union_types(ctx: &BindgenContext,
                                result: &mut Vec<P<ast::Item>>) {
         let prefix = ctx.trait_prefix();

src/ir/mod.rs

@@ -17,3 +17,4 @@ pub mod module;
 pub mod ty;
 pub mod type_collector;
 pub mod var;
+pub mod objc;

src/ir/objc.rs

@@ -0,0 +1,78 @@
+//! Objective C types
+
+use clang;
+use clang_sys::CXChildVisit_Continue;
+use clang_sys::CXCursor_ObjCInstanceMethodDecl;
+// use clang_sys::CXCursor_ObjCSuperClassRef;
+use super::context::BindgenContext;
+
+/// Objective C interface as used in TypeKind
+///
+/// Also protocols are parsed as this type
+#[derive(Debug)]
+pub struct ObjCInterface {
+    /// The name
+    /// like, NSObject
+    pub name: String,
+
+    /// List of the methods defined in this interfae
+    pub methods: Vec<ObjCInstanceMethod>,
+}
+
+/// The objective c methods
+#[derive(Debug)]
+pub struct ObjCInstanceMethod {
+    /// The original method selector name
+    /// like, dataWithBytes:length:
+    pub name: String,
+
+    /// Method name as converted to rust
+    /// like, dataWithBytes_length_
+    pub rust_name: String,
+}
+
+impl ObjCInterface {
+    fn new(name: &str) -> ObjCInterface {
+        ObjCInterface {
+            name: name.to_owned(),
+            methods: Vec::new(),
+        }
+    }
+
+    /// Parses the Objective C interface from the cursor
+    pub fn from_ty(cursor: &clang::Cursor,
+                   _ctx: &mut BindgenContext)
+                   -> Option<Self> {
+        let name = cursor.spelling();
+        let mut interface = Self::new(&name);
+
+        cursor.visit(|cursor| {
+            match cursor.kind() {
+                CXCursor_ObjCInstanceMethodDecl => {
+                    let name = cursor.spelling();
+                    let method = ObjCInstanceMethod::new(&name);
+
+                    interface.methods.push(method);
+                }
+                _ => {}
+            }
+            CXChildVisit_Continue
+        });
+        Some(interface)
+    }
+}
+
+
+impl ObjCInstanceMethod {
+    fn new(name: &str) -> ObjCInstanceMethod {
+
+        let split_name: Vec<&str> = name.split(':').collect();
+
+        let rust_name = split_name.join("_");
+
+        ObjCInstanceMethod {
+            name: name.to_owned(),
+            rust_name: rust_name.to_owned(),
+        }
+    }
+}

src/ir/ty.rs

@@ -10,6 +10,7 @@ use super::function::FunctionSig;
 use super::int::IntKind;
 use super::item::Item;
 use super::layout::Layout;
+use super::objc::ObjCInterface;
 use super::type_collector::{ItemSet, TypeCollector};
 
 /// The base representation of a type in bindgen.
@@ -312,7 +313,8 @@ impl Type {
             TypeKind::Void |
             TypeKind::NullPtr |
             TypeKind::BlockPointer |
-            TypeKind::Pointer(..) => Some(self),
+            TypeKind::Pointer(..) |
+            TypeKind::ObjCInterface(..) => Some(self),
 
             TypeKind::ResolvedTypeRef(inner) |
             TypeKind::Alias(_, inner) |
@@ -480,6 +482,9 @@ pub enum TypeKind {
 
     /// A named type, that is, a template parameter.
     Named(String),
+
+    /// Objective C interface. Always referenced through a pointer
+    ObjCInterface(ObjCInterface),
 }
 
 impl Type {
@@ -513,6 +518,8 @@ impl Type {
             TypeKind::BlockPointer |
             TypeKind::Pointer(..) => false,
 
+            TypeKind::ObjCInterface(..) => true, // dunno?
+
             TypeKind::UnresolvedTypeRef(..) => {
                 unreachable!("Should have been resolved after parsing!");
             }
@@ -554,7 +561,16 @@ impl Type {
         debug!("currently_parsed_types: {:?}", ctx.currently_parsed_types);
 
         let canonical_ty = ty.canonical_type();
-        let kind = match ty.kind() {
+
+        // Parse objc protocols as if they were interfaces
+        let mut ty_kind = ty.kind();
+        if let Some(loc) = location {
+            if loc.kind() == CXCursor_ObjCProtocolDecl {
+                ty_kind = CXType_ObjCInterface;
+            }
+        }
+
+        let kind = match ty_kind {
             CXType_Unexposed if *ty != canonical_ty &&
                                 canonical_ty.kind() != CXType_Invalid => {
                 debug!("Looking for canonical type: {:?}", canonical_ty);
@@ -795,6 +811,7 @@ impl Type {
             //
             // We might need to, though, if the context is already in the
             // process of resolving them.
+            CXType_ObjCObjectPointer |
             CXType_MemberPointer |
             CXType_Pointer => {
                 let inner = Item::from_ty_or_ref(ty.pointee_type().unwrap(),
@@ -869,6 +886,11 @@ impl Type {
                                            parent_id,
                                            ctx);
             }
+            CXType_ObjCInterface => {
+                let interface = ObjCInterface::from_ty(&location.unwrap(), ctx)
+                    .expect("Not a valid objc interface?");
+                TypeKind::ObjCInterface(interface)
+            }
             _ => {
                 error!("unsupported type: kind = {:?}; ty = {:?}; at {:?}",
                        ty.kind(),
@@ -923,6 +945,10 @@ impl TypeCollector for Type {
                 types.insert(id);
             }
 
+            TypeKind::ObjCInterface(_) => {
+                // TODO:
+            }
+
             // None of these variants have edges to other items and types.
             TypeKind::UnresolvedTypeRef(_, _, None) |
             TypeKind::Named(_) |