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;
@@ -87,6 +88,9 @@ struct CodegenResult<'a> {
     /// Whether an incomplete array has been generated at least once.
     saw_incomplete_array: bool,
 
+    /// Whether Objective C types have been seen at least once.
+    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:
@@ -119,6 +123,7 @@ impl<'a> CodegenResult<'a> {
             items: vec![],
             saw_union: false,
             saw_incomplete_array: false,
+            saw_objc: false,
             codegen_id: codegen_id,
             items_seen: Default::default(),
             functions_seen: Default::default(),
@@ -140,6 +145,10 @@ impl<'a> CodegenResult<'a> {
         self.saw_incomplete_array = true;
     }
 
+    fn saw_objc(&mut self) {
+        self.saw_objc = true;
+    }
+
     fn seen(&self, item: ItemId) -> bool {
         self.items_seen.contains(&item)
     }
@@ -184,6 +193,7 @@ impl<'a> CodegenResult<'a> {
 
         self.saw_union |= new.saw_union;
         self.saw_incomplete_array |= new.saw_incomplete_array;
+        self.saw_objc |= new.saw_objc;
 
         new.items
     }
@@ -359,6 +369,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);
+                }
             }
         };
 
@@ -622,6 +635,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)
             }
@@ -2109,6 +2125,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)
             }
@@ -2142,10 +2162,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 {
@@ -2261,6 +2295,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);
@@ -2294,6 +2412,38 @@ 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;
+
+        if ctx.options().objc_extern_crate {
+            use_objc = quote_item!(ctx.ext_cx(),
+                use objc;
+            )
+                .unwrap();
+        } else {
+            use_objc = quote_item!(ctx.ext_cx(),
+                #[macro_use]
+                extern crate 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(),
+        }
+    }
+}