Added inheritance to objective-c support and changed unsafe logic.

simlay · simlay · commit 4c1fb081b5f1 · 2020-03-18T17:37:46.000-07:00
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
@@ -3674,19 +3674,19 @@ fn objc_method_codegen(
                 .to_owned(),
         );
         quote! {
-            msg_send!(class!(#class_name), #methods_and_args)
+            unsafe { msg_send!(class!(#class_name), #methods_and_args) }
         }
     } else {
         quote! {
-            msg_send!(self, #methods_and_args)
+            unsafe { msg_send!(self, #methods_and_args) }
         }
     };
 
     let method_name =
         ctx.rust_ident(format!("{}{}", prefix, method.rust_name()));
 
     quote! {
-        unsafe fn #method_name #sig where <Self as std::ops::Deref>::Target: objc::Message + Sized {
+        fn #method_name #sig where <Self as std::ops::Deref>::Target: objc::Message + Sized {
             #body
         }
     }
@@ -3785,6 +3785,31 @@ impl CodeGenerator for ObjCInterface {
                 };
                 result.push(impl_trait);
             }
+            for parent_id in self.parent_classes.iter() {
+                match ctx.resolve_type(parent_id.expect_type_id(ctx)).kind() {
+                    TypeKind::ObjCInterface(ref parent) => {
+                        let parent_name = ctx.rust_ident(parent.rust_name());
+                        let impl_trait = if parent.is_template() {
+                            let template_names: Vec<Ident> = parent
+                                .template_names
+                                .iter()
+                                .map(|g| ctx.rust_ident(g))
+                                .collect();
+                            quote! {
+                                impl <#(#template_names :'static),*> #parent_name <#(#template_names),*> for #class_name {
+                                }
+                            }
+                        } else {
+                            quote! {
+                                impl #parent_name for #class_name { }
+                            }
+                        };
+                        result.push(impl_trait);
+                    }
+                    _ => {}
+                }
+
+            }
         }
 
         if !self.is_protocol() {
diff --git a/src/ir/objc.rs b/src/ir/objc.rs
@@ -7,6 +7,7 @@ use super::ty::TypeKind;
 use clang;
 use clang_sys::CXChildVisit_Continue;
 use clang_sys::CXCursor_ObjCCategoryDecl;
+use clang_sys::CXCursor_ObjCSuperClassRef;
 use clang_sys::CXCursor_ObjCClassMethodDecl;
 use clang_sys::CXCursor_ObjCClassRef;
 use clang_sys::CXCursor_ObjCInstanceMethodDecl;
@@ -34,6 +35,8 @@ pub struct ObjCInterface {
     /// The list of protocols that this interface conforms to.
     pub conforms_to: Vec<ItemId>,
 
+    pub parent_classes: Vec<ItemId>,
+
     /// List of the methods defined in this interfae
     methods: Vec<ObjCMethod>,
 
@@ -64,6 +67,7 @@ impl ObjCInterface {
             category: None,
             is_protocol: false,
             template_names: Vec::new(),
+            parent_classes: Vec::new(),
             conforms_to: Vec::new(),
             methods: Vec::new(),
             class_methods: Vec::new(),
@@ -179,6 +183,35 @@ impl ObjCInterface {
                     let name = c.spelling();
                     interface.template_names.push(name);
                 }
+                CXCursor_ObjCSuperClassRef => {
+                    let items_map = ctx.items();
+
+                    let needle = format!("I{}", c.spelling());
+                    debug!("Interface {} has a parent class {}, find the item", interface.name, needle);
+
+                    for (id, item) in items_map
+                    {
+                        if let Some(ty) = item.as_type() {
+                            match *ty.kind() {
+                                TypeKind::ObjCInterface(ref class) => {
+                                    if !class.is_protocol
+                                    {
+                                        debug!("Checking class {}, ty.name {:?}", class.name, ty.name());
+                                        if Some(needle.as_ref()) == ty.name() {
+                                            debug!("Found parent class {:?}", item);
+                                            interface.parent_classes.push(id);
+                                            for i in class.parent_classes.clone() {
+                                                interface.parent_classes.push(i);
+                                            }
+                                            break;
+                                        }
+                                    }
+                                }
+                                _=> {}
+                            }
+                        }
+                    }
+                },
                 _ => {}
             }
             CXChildVisit_Continue
diff --git a/tests/expectations/tests/libclang-9/objc_inheritance.rs b/tests/expectations/tests/libclang-9/objc_inheritance.rs
@@ -0,0 +1,70 @@
+/* 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 Baz(pub id);
+impl std::ops::Deref for Baz {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Baz {}
+impl Baz {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(objc::class!(Baz), alloc) })
+    }
+}
+impl IBaz for Baz {}
+pub trait IBaz: Sized + std::ops::Deref {
+    fn initWithFirstNumber_(
+        self,
+        firstNumber: ::std::os::raw::c_int,
+    ) -> instancetype
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        unsafe { msg_send!(self, initWithFirstNumber: firstNumber) }
+    }
+}
+#[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 IBaz for Foo {}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    fn initWithFirstNumber_(
+        self,
+        firstNumber: ::std::os::raw::c_int,
+    ) -> instancetype
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        unsafe { msg_send!(self, initWithFirstNumber: firstNumber) }
+    }
+}
+pub type instancetype = id;
diff --git a/tests/expectations/tests/libclang-9/objc_template.rs b/tests/expectations/tests/libclang-9/objc_template.rs
@@ -29,11 +29,11 @@ impl Foo {
 }
 impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}
 pub trait IFoo<ObjectType>: Sized + std::ops::Deref {
-    unsafe fn get(self) -> u64
+    fn get(self) -> u64
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, get)
+        unsafe { msg_send!(self, get) }
     }
 }
 #[repr(transparent)]
@@ -58,10 +58,10 @@ impl<KeyType: 'static, ObjectType: 'static>
 pub trait IFooMultiGeneric<KeyType, ObjectType>:
     Sized + std::ops::Deref
 {
-    unsafe fn objectForKey_(self, key: u64) -> u64
+    fn objectForKey_(self, key: u64) -> u64
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, objectForKey: key)
+        unsafe { msg_send!(self, objectForKey: key) }
     }
 }
diff --git a/tests/expectations/tests/objc_category.rs b/tests/expectations/tests/objc_category.rs
@@ -29,19 +29,19 @@ impl Foo {
 }
 impl IFoo for Foo {}
 pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method(self)
+    fn method(self)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, method)
+        unsafe { msg_send!(self, method) }
     }
 }
 impl Foo_BarCategory for Foo {}
 pub trait Foo_BarCategory: Sized + std::ops::Deref {
-    unsafe fn categoryMethod(self)
+    fn categoryMethod(self)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, categoryMethod)
+        unsafe { msg_send!(self, categoryMethod) }
     }
 }
diff --git a/tests/expectations/tests/objc_class.rs b/tests/expectations/tests/objc_class.rs
@@ -32,10 +32,10 @@ impl Foo {
 }
 impl IFoo for Foo {}
 pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method(self)
+    fn method(self)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, method)
+        unsafe { msg_send!(self, method) }
     }
 }
diff --git a/tests/expectations/tests/objc_class_method.rs b/tests/expectations/tests/objc_class_method.rs
@@ -29,43 +29,45 @@ impl Foo {
 }
 impl IFoo for Foo {}
 pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method()
+    fn method()
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(class!(Foo), method)
+        unsafe { msg_send!(class!(Foo), method) }
     }
-    unsafe fn methodWithInt_(foo: ::std::os::raw::c_int)
+    fn methodWithInt_(foo: ::std::os::raw::c_int)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(class!(Foo), methodWithInt: foo)
+        unsafe { msg_send!(class!(Foo), methodWithInt: foo) }
     }
-    unsafe fn methodWithFoo_(foo: id)
+    fn methodWithFoo_(foo: id)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(class!(Foo), methodWithFoo: foo)
+        unsafe { msg_send!(class!(Foo), methodWithFoo: foo) }
     }
-    unsafe fn methodReturningInt() -> ::std::os::raw::c_int
+    fn methodReturningInt() -> ::std::os::raw::c_int
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(class!(Foo), methodReturningInt)
+        unsafe { msg_send!(class!(Foo), methodReturningInt) }
     }
-    unsafe fn methodReturningFoo() -> *mut objc::runtime::Object
+    fn methodReturningFoo() -> *mut objc::runtime::Object
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(class!(Foo), methodReturningFoo)
+        unsafe { msg_send!(class!(Foo), methodReturningFoo) }
     }
-    unsafe fn methodWithArg1_andArg2_andArg3_(
+    fn methodWithArg1_andArg2_andArg3_(
         intvalue: ::std::os::raw::c_int,
         ptr: *mut ::std::os::raw::c_char,
         floatvalue: f32,
     ) where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send ! ( class ! ( Foo ) , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )
+        unsafe {
+            msg_send ! ( class ! ( Foo ) , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )
+        }
     }
 }
diff --git a/tests/expectations/tests/objc_method.rs b/tests/expectations/tests/objc_method.rs
@@ -29,47 +29,49 @@ impl Foo {
 }
 impl IFoo for Foo {}
 pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method(self)
+    fn method(self)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, method)
+        unsafe { msg_send!(self, method) }
     }
-    unsafe fn methodWithInt_(self, foo: ::std::os::raw::c_int)
+    fn methodWithInt_(self, foo: ::std::os::raw::c_int)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, methodWithInt: foo)
+        unsafe { msg_send!(self, methodWithInt: foo) }
     }
-    unsafe fn methodWithFoo_(self, foo: id)
+    fn methodWithFoo_(self, foo: id)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, methodWithFoo: foo)
+        unsafe { msg_send!(self, methodWithFoo: foo) }
     }
-    unsafe fn methodReturningInt(self) -> ::std::os::raw::c_int
+    fn methodReturningInt(self) -> ::std::os::raw::c_int
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, methodReturningInt)
+        unsafe { msg_send!(self, methodReturningInt) }
     }
-    unsafe fn methodReturningFoo(self) -> *mut objc::runtime::Object
+    fn methodReturningFoo(self) -> *mut objc::runtime::Object
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send!(self, methodReturningFoo)
+        unsafe { msg_send!(self, methodReturningFoo) }
     }
-    unsafe fn methodWithArg1_andArg2_andArg3_(
+    fn methodWithArg1_andArg2_andArg3_(
         self,
         intvalue: ::std::os::raw::c_int,
         ptr: *mut ::std::os::raw::c_char,
         floatvalue: f32,
     ) where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send ! ( self , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )
+        unsafe {
+            msg_send ! ( self , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )
+        }
     }
-    unsafe fn methodWithAndWithoutKeywords_arg2Name__arg4Name_(
+    fn methodWithAndWithoutKeywords_arg2Name__arg4Name_(
         self,
         arg1: ::std::os::raw::c_int,
         arg2: f32,
@@ -79,7 +81,9 @@ pub trait IFoo: Sized + std::ops::Deref {
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
-        msg_send ! ( self , methodWithAndWithoutKeywords : arg1 arg2Name : arg2 arg3 : arg3 arg4Name : arg4 )
+        unsafe {
+            msg_send ! ( self , methodWithAndWithoutKeywords : arg1 arg2Name : arg2 arg3 : arg3 arg4Name : arg4 )
+        }
     }
 }
 pub type instancetype = id;
diff --git a/tests/expectations/tests/objc_method_clash.rs b/tests/expectations/tests/objc_method_clash.rs
diff --git a/tests/expectations/tests/objc_property_fnptr.rs b/tests/expectations/tests/objc_property_fnptr.rs
diff --git a/tests/headers/objc_inheritance.h b/tests/headers/objc_inheritance.h

Original file line number	Diff line number	Diff line change
`@@ -29,11 +29,11 @@ impl Foo {`
`29`	`29`	`}`
`30`	`30`	`impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}`
`31`	`31`	`pub trait IFoo<ObjectType>: Sized + std::ops::Deref {`
`32`		`- unsafe fn get(self) -> u64`
	`32`	`+ fn get(self) -> u64`
`33`	`33`	`where`
`34`	`34`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`35`	`35`	`{`
`36`		`- msg_send!(self, get)`
	`36`	`+ unsafe { msg_send!(self, get) }`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`#[repr(transparent)]`
`@@ -58,10 +58,10 @@ impl<KeyType: 'static, ObjectType: 'static>`
`58`	`58`	`pub trait IFooMultiGeneric<KeyType, ObjectType>:`
`59`	`59`	`Sized + std::ops::Deref`
`60`	`60`	`{`
`61`		`- unsafe fn objectForKey_(self, key: u64) -> u64`
	`61`	`+ fn objectForKey_(self, key: u64) -> u64`
`62`	`62`	`where`
`63`	`63`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`64`	`64`	`{`
`65`		`- msg_send!(self, objectForKey: key)`
	`65`	`+ unsafe { msg_send!(self, objectForKey: key) }`
`66`	`66`	`}`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,19 +29,19 @@ impl Foo {`
`29`	`29`	`}`
`30`	`30`	`impl IFoo for Foo {}`
`31`	`31`	`pub trait IFoo: Sized + std::ops::Deref {`
`32`		`- unsafe fn method(self)`
	`32`	`+ fn method(self)`
`33`	`33`	`where`
`34`	`34`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`35`	`35`	`{`
`36`		`- msg_send!(self, method)`
	`36`	`+ unsafe { msg_send!(self, method) }`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`impl Foo_BarCategory for Foo {}`
`40`	`40`	`pub trait Foo_BarCategory: Sized + std::ops::Deref {`
`41`		`- unsafe fn categoryMethod(self)`
	`41`	`+ fn categoryMethod(self)`
`42`	`42`	`where`
`43`	`43`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`44`	`44`	`{`
`45`		`- msg_send!(self, categoryMethod)`
	`45`	`+ unsafe { msg_send!(self, categoryMethod) }`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,10 +32,10 @@ impl Foo {`
`32`	`32`	`}`
`33`	`33`	`impl IFoo for Foo {}`
`34`	`34`	`pub trait IFoo: Sized + std::ops::Deref {`
`35`		`- unsafe fn method(self)`
	`35`	`+ fn method(self)`
`36`	`36`	`where`
`37`	`37`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`38`	`38`	`{`
`39`		`- msg_send!(self, method)`
	`39`	`+ unsafe { msg_send!(self, method) }`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,43 +29,45 @@ impl Foo {`
`29`	`29`	`}`
`30`	`30`	`impl IFoo for Foo {}`
`31`	`31`	`pub trait IFoo: Sized + std::ops::Deref {`
`32`		`- unsafe fn method()`
	`32`	`+ fn method()`
`33`	`33`	`where`
`34`	`34`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`35`	`35`	`{`
`36`		`- msg_send!(class!(Foo), method)`
	`36`	`+ unsafe { msg_send!(class!(Foo), method) }`
`37`	`37`	`}`
`38`		`- unsafe fn methodWithInt_(foo: ::std::os::raw::c_int)`
	`38`	`+ fn methodWithInt_(foo: ::std::os::raw::c_int)`
`39`	`39`	`where`
`40`	`40`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`41`	`41`	`{`
`42`		`- msg_send!(class!(Foo), methodWithInt: foo)`
	`42`	`+ unsafe { msg_send!(class!(Foo), methodWithInt: foo) }`
`43`	`43`	`}`
`44`		`- unsafe fn methodWithFoo_(foo: id)`
	`44`	`+ fn methodWithFoo_(foo: id)`
`45`	`45`	`where`
`46`	`46`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`47`	`47`	`{`
`48`		`- msg_send!(class!(Foo), methodWithFoo: foo)`
	`48`	`+ unsafe { msg_send!(class!(Foo), methodWithFoo: foo) }`
`49`	`49`	`}`
`50`		`- unsafe fn methodReturningInt() -> ::std::os::raw::c_int`
	`50`	`+ fn methodReturningInt() -> ::std::os::raw::c_int`
`51`	`51`	`where`
`52`	`52`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`53`	`53`	`{`
`54`		`- msg_send!(class!(Foo), methodReturningInt)`
	`54`	`+ unsafe { msg_send!(class!(Foo), methodReturningInt) }`
`55`	`55`	`}`
`56`		`- unsafe fn methodReturningFoo() -> *mut objc::runtime::Object`
	`56`	`+ fn methodReturningFoo() -> *mut objc::runtime::Object`
`57`	`57`	`where`
`58`	`58`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`59`	`59`	`{`
`60`		`- msg_send!(class!(Foo), methodReturningFoo)`
	`60`	`+ unsafe { msg_send!(class!(Foo), methodReturningFoo) }`
`61`	`61`	`}`
`62`		`- unsafe fn methodWithArg1_andArg2_andArg3_(`
	`62`	`+ fn methodWithArg1_andArg2_andArg3_(`
`63`	`63`	`intvalue: ::std::os::raw::c_int,`
`64`	`64`	`ptr: *mut ::std::os::raw::c_char,`
`65`	`65`	`floatvalue: f32,`
`66`	`66`	`) where`
`67`	`67`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`68`	`68`	`{`
`69`		`- msg_send ! ( class ! ( Foo ) , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )`
	`69`	`+ unsafe {`
	`70`	`+ msg_send ! ( class ! ( Foo ) , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )`
	`71`	`+ }`
`70`	`72`	`}`
`71`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,47 +29,49 @@ impl Foo {`
`29`	`29`	`}`
`30`	`30`	`impl IFoo for Foo {}`
`31`	`31`	`pub trait IFoo: Sized + std::ops::Deref {`
`32`		`- unsafe fn method(self)`
	`32`	`+ fn method(self)`
`33`	`33`	`where`
`34`	`34`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`35`	`35`	`{`
`36`		`- msg_send!(self, method)`
	`36`	`+ unsafe { msg_send!(self, method) }`
`37`	`37`	`}`
`38`		`- unsafe fn methodWithInt_(self, foo: ::std::os::raw::c_int)`
	`38`	`+ fn methodWithInt_(self, foo: ::std::os::raw::c_int)`
`39`	`39`	`where`
`40`	`40`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`41`	`41`	`{`
`42`		`- msg_send!(self, methodWithInt: foo)`
	`42`	`+ unsafe { msg_send!(self, methodWithInt: foo) }`
`43`	`43`	`}`
`44`		`- unsafe fn methodWithFoo_(self, foo: id)`
	`44`	`+ fn methodWithFoo_(self, foo: id)`
`45`	`45`	`where`
`46`	`46`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`47`	`47`	`{`
`48`		`- msg_send!(self, methodWithFoo: foo)`
	`48`	`+ unsafe { msg_send!(self, methodWithFoo: foo) }`
`49`	`49`	`}`
`50`		`- unsafe fn methodReturningInt(self) -> ::std::os::raw::c_int`
	`50`	`+ fn methodReturningInt(self) -> ::std::os::raw::c_int`
`51`	`51`	`where`
`52`	`52`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`53`	`53`	`{`
`54`		`- msg_send!(self, methodReturningInt)`
	`54`	`+ unsafe { msg_send!(self, methodReturningInt) }`
`55`	`55`	`}`
`56`		`- unsafe fn methodReturningFoo(self) -> *mut objc::runtime::Object`
	`56`	`+ fn methodReturningFoo(self) -> *mut objc::runtime::Object`
`57`	`57`	`where`
`58`	`58`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`59`	`59`	`{`
`60`		`- msg_send!(self, methodReturningFoo)`
	`60`	`+ unsafe { msg_send!(self, methodReturningFoo) }`
`61`	`61`	`}`
`62`		`- unsafe fn methodWithArg1_andArg2_andArg3_(`
	`62`	`+ fn methodWithArg1_andArg2_andArg3_(`
`63`	`63`	`self,`
`64`	`64`	`intvalue: ::std::os::raw::c_int,`
`65`	`65`	`ptr: *mut ::std::os::raw::c_char,`
`66`	`66`	`floatvalue: f32,`
`67`	`67`	`) where`
`68`	`68`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`69`	`69`	`{`
`70`		`- msg_send ! ( self , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )`
	`70`	`+ unsafe {`
	`71`	`+ msg_send ! ( self , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue )`
	`72`	`+ }`
`71`	`73`	`}`
`72`		`- unsafe fn methodWithAndWithoutKeywords_arg2Name__arg4Name_(`
	`74`	`+ fn methodWithAndWithoutKeywords_arg2Name__arg4Name_(`
`73`	`75`	`self,`
`74`	`76`	`arg1: ::std::os::raw::c_int,`
`75`	`77`	`arg2: f32,`
`@@ -79,7 +81,9 @@ pub trait IFoo: Sized + std::ops::Deref {`
`79`	`81`	`where`
`80`	`82`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`81`	`83`	`{`
`82`		`- msg_send ! ( self , methodWithAndWithoutKeywords : arg1 arg2Name : arg2 arg3 : arg3 arg4Name : arg4 )`
	`84`	`+ unsafe {`
	`85`	`+ msg_send ! ( self , methodWithAndWithoutKeywords : arg1 arg2Name : arg2 arg3 : arg3 arg4Name : arg4 )`
	`86`	`+ }`
`83`	`87`	`}`
`84`	`88`	`}`
`85`	`89`	`pub type instancetype = id;`