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) },
                 };
@@ -785,6 +786,10 @@ impl Type {
                 !args.any(|t| t.spelling().contains("type-parameter"))
             })
     }
+
+    pub fn objc_encoding(&self) -> String {
+        unsafe { cxstring_into_string(clang_Type_getObjCEncoding(self.x)) }
+    }
 }
 
 /// An iterator for a type's template arguments.

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
     }
@@ -342,6 +351,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);
+                }
             }
         };
 
@@ -586,6 +598,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)
             }
@@ -2062,6 +2077,13 @@ impl ToRustTy for Type {
                 let ident = ctx.rust_ident(&name);
                 quote_ty!(ctx.ext_cx(), $ident)
             }
+
+            TypeKind::ObjCInterface(..) => {
+                let name = item.canonical_name(ctx);
+                let ident = ctx.rust_ident(&name);
+                quote_ty!(ctx.ext_cx(), $ident)
+            }
+
             ref u @ TypeKind::UnresolvedTypeRef(..) => {
                 unreachable!("Should have been resolved after parsing {:?}!", u)
             }
@@ -2095,10 +2117,27 @@ 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")
+                        //inner.to_rust_ty(ctx)
             } else {
                 arg_item.to_rust_ty(ctx)
+                    }
+                },
+                _ => {
+                    arg_item.to_rust_ty(ctx)
+                }
             };
 
             let arg_name = match *name {
@@ -2214,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);
@@ -2247,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,66 @@
+use clang;
+use clang_sys::CXChildVisit_Continue;
+use clang_sys::CXCursor_ObjCInstanceMethodDecl;
+// use clang_sys::CXCursor_ObjCSuperClassRef;
+use super::context::BindgenContext;
+
+#[derive(Debug)]
+pub struct ObjCInterface {
+    pub name: String,
+    pub methods: Vec<ObjCInstanceMethod>,
+}
+
+#[derive(Debug)]
+pub struct ObjCInstanceMethod {
+    pub name: String, // signature
+    pub rust_name: String,
+}
+
+impl ObjCInterface {
+    fn new(name: &str) -> ObjCInterface {
+        ObjCInterface {
+            name: name.to_owned(),
+            methods: Vec::new(),
+        }
+    }
+
+    pub fn from_ty(cursor: &clang::Cursor,
+                   _ctx: &mut BindgenContext)
+                   -> Option<Self> {
+        let name = cursor.spelling();
+        let mut interface = Self::new(&name);
+
+        if true {
+            println!("cursor type {:?}", cursor.cur_type());
+        }
+
+        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(),
+        }
+    }
+}