Fix CI attempt 1

simlay · simlay · commit 3ab135083ea8 · 2020-02-28T10:04:48.000-08:00
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
@@ -3752,7 +3752,7 @@ impl CodeGenerator for ObjCInterface {
             }
         };
 
-        let struct_name = ctx.rust_ident(self.struct_name());
+        let struct_name = ctx.rust_ident(self.name());
         if !(self.is_category() || self.is_protocol()) {
             let class_name = ctx.rust_ident(self.name());
             let struct_block = quote! {
diff --git a/src/ir/objc.rs b/src/ir/objc.rs
@@ -31,6 +31,7 @@ pub struct ObjCInterface {
     /// The list of template names almost always, ObjectType or KeyType
     pub template_names: Vec<String>,
 
+    /// The list of protocols that this interface conforms to.
     pub conforms_to: Vec<ItemId>,
 
     /// List of the methods defined in this interfae
@@ -77,7 +78,7 @@ impl ObjCInterface {
 
     /// Formats the name for rust
     /// Can be like NSObject, but with categories might be like NSObject_NSCoderMethods
-    /// and protocols are like protocol_NSObject
+    /// and protocols are like PNSObject
     pub fn rust_name(&self) -> String {
         if let Some(ref cat) = self.category {
             format!("{}_{}", self.name(), cat)
@@ -90,10 +91,6 @@ impl ObjCInterface {
         }
     }
 
-    pub fn struct_name(&self) -> String {
-        format!("{}", self.name().to_owned())
-    }
-
     /// Is this a template interface?
     pub fn is_template(&self) -> bool {
         !self.template_names.is_empty()
@@ -143,7 +140,7 @@ impl ObjCInterface {
                 }
                 CXCursor_ObjCProtocolRef => {
                     // Gather protocols this interface conforms to
-                    let needle = format!("protocol_{}", c.spelling());
+                    let needle = format!("P{}", c.spelling());
                     let items_map = ctx.items();
                     debug!("Interface {} conforms to {}, find the item", interface.name, needle);
 
diff --git a/tests/expectations/tests/libclang-9/objc_template.rs b/tests/expectations/tests/libclang-9/objc_template.rs
@@ -13,21 +13,22 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl<ObjectType: 'static> interface_Foo<ObjectType> for struct_Foo {}
-pub trait interface_Foo<ObjectType>: Sized + std::ops::Deref {
+impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}
+pub trait IFoo<ObjectType>: Sized + std::ops::Deref {
     unsafe fn get(self) -> u64
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
@@ -36,24 +37,25 @@ pub trait interface_Foo<ObjectType>: Sized + std::ops::Deref {
     }
 }
 #[repr(transparent)]
-pub struct struct_FooMultiGeneric(pub id);
-impl std::ops::Deref for struct_FooMultiGeneric {
+#[derive(Clone, Copy)]
+pub struct FooMultiGeneric(pub id);
+impl std::ops::Deref for FooMultiGeneric {
     type Target = objc::runtime::Object;
     fn deref(&self) -> &Self::Target {
         unsafe { &*self.0 }
     }
 }
-unsafe impl objc::Message for struct_FooMultiGeneric {}
-impl struct_FooMultiGeneric {
+unsafe impl objc::Message for FooMultiGeneric {}
+impl FooMultiGeneric {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(FooMultiGeneric), alloc) })
     }
 }
 impl<KeyType: 'static, ObjectType: 'static>
-    interface_FooMultiGeneric<KeyType, ObjectType> for struct_FooMultiGeneric
+    IFooMultiGeneric<KeyType, ObjectType> for FooMultiGeneric
 {
 }
-pub trait interface_FooMultiGeneric<KeyType, ObjectType>:
+pub trait IFooMultiGeneric<KeyType, ObjectType>:
     Sized + std::ops::Deref
 {
     unsafe fn objectForKey_(self, key: u64) -> u64
diff --git a/tests/expectations/tests/objc_category.rs b/tests/expectations/tests/objc_category.rs
@@ -13,29 +13,30 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {
+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 struct_Foo {}
+impl Foo_BarCategory for Foo {}
 pub trait Foo_BarCategory: Sized + std::ops::Deref {
     unsafe fn categoryMethod(self)
     where
diff --git a/tests/expectations/tests/objc_class.rs b/tests/expectations/tests/objc_class.rs
@@ -13,24 +13,25 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 extern "C" {
-    pub static mut fooVar: *mut id;
+    pub static mut fooVar: *mut objc::runtime::Object;
 }
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {
+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,
diff --git a/tests/expectations/tests/objc_class_method.rs b/tests/expectations/tests/objc_class_method.rs
@@ -13,21 +13,22 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
     unsafe fn method()
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
@@ -52,7 +53,7 @@ pub trait interface_Foo: Sized + std::ops::Deref {
     {
         msg_send!(class!(Foo), methodReturningInt)
     }
-    unsafe fn methodReturningFoo() -> *mut id
+    unsafe fn methodReturningFoo() -> *mut objc::runtime::Object
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
diff --git a/tests/expectations/tests/objc_interface.rs b/tests/expectations/tests/objc_interface.rs
@@ -13,19 +13,20 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {}
-pub trait protocol_bar: Sized + std::ops::Deref {}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
+pub trait Pbar: Sized + std::ops::Deref {}
diff --git a/tests/expectations/tests/objc_interface_type.rs b/tests/expectations/tests/objc_interface_type.rs
@@ -13,25 +13,26 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct FooStruct {
-    pub foo: *mut id,
+    pub foo: *mut objc::runtime::Object,
 }
 #[test]
 fn bindgen_test_layout_FooStruct() {
@@ -67,5 +68,5 @@ extern "C" {
     pub fn fooFunc(foo: id);
 }
 extern "C" {
-    pub static mut kFoo: *const id;
+    pub static mut kFoo: *const objc::runtime::Object;
 }
diff --git a/tests/expectations/tests/objc_method.rs b/tests/expectations/tests/objc_method.rs
@@ -13,21 +13,22 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {
+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,
@@ -52,7 +53,7 @@ pub trait interface_Foo: Sized + std::ops::Deref {
     {
         msg_send!(self, methodReturningInt)
     }
-    unsafe fn methodReturningFoo(self) -> *mut id
+    unsafe fn methodReturningFoo(self) -> *mut objc::runtime::Object
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
     {
diff --git a/tests/expectations/tests/objc_method_clash.rs b/tests/expectations/tests/objc_method_clash.rs
@@ -13,21 +13,22 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
     unsafe fn foo(self)
     where
         <Self as std::ops::Deref>::Target: objc::Message + Sized,
diff --git a/tests/expectations/tests/objc_property_fnptr.rs b/tests/expectations/tests/objc_property_fnptr.rs
@@ -13,21 +13,22 @@ extern crate objc;
 #[allow(non_camel_case_types)]
 pub type id = *mut objc::runtime::Object;
 #[repr(transparent)]
-pub struct struct_Foo(pub id);
-impl std::ops::Deref for struct_Foo {
+#[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 struct_Foo {}
-impl struct_Foo {
+unsafe impl objc::Message for Foo {}
+impl Foo {
     pub fn alloc() -> Self {
         Self(unsafe { msg_send!(objc::class!(Foo), alloc) })
     }
 }
-impl interface_Foo for struct_Foo {}
-pub trait interface_Foo: Sized + std::ops::Deref {
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
     unsafe fn func(
         self,
     ) -> ::std::option::Option<
diff --git a/tests/expectations/tests/objc_protocol.rs b/tests/expectations/tests/objc_protocol.rs
diff --git a/tests/expectations/tests/objc_whitelist.rs b/tests/expectations/tests/objc_whitelist.rs

Original file line number	Diff line number	Diff line change
`@@ -3752,7 +3752,7 @@ impl CodeGenerator for ObjCInterface {`
`3752`	`3752`	`}`
`3753`	`3753`	`};`
`3754`	`3754`
`3755`		`- let struct_name = ctx.rust_ident(self.struct_name());`
	`3755`	`+ let struct_name = ctx.rust_ident(self.name());`
`3756`	`3756`	`if !(self.is_category() \|\| self.is_protocol()) {`
`3757`	`3757`	`let class_name = ctx.rust_ident(self.name());`
`3758`	`3758`	`let struct_block = quote! {`
Original file line number	Diff line number	Diff line change
`@@ -13,21 +13,22 @@ extern crate objc;`
`13`	`13`	`#[allow(non_camel_case_types)]`
`14`	`14`	`pub type id = *mut objc::runtime::Object;`
`15`	`15`	`#[repr(transparent)]`
`16`		`-pub struct struct_Foo(pub id);`
`17`		`-impl std::ops::Deref for struct_Foo {`
	`16`	`+#[derive(Clone, Copy)]`
	`17`	`+pub struct Foo(pub id);`
	`18`	`+impl std::ops::Deref for Foo {`
`18`	`19`	`type Target = objc::runtime::Object;`
`19`	`20`	`fn deref(&self) -> &Self::Target {`
`20`	`21`	`unsafe { &*self.0 }`
`21`	`22`	`}`
`22`	`23`	`}`
`23`		`-unsafe impl objc::Message for struct_Foo {}`
`24`		`-impl struct_Foo {`
	`24`	`+unsafe impl objc::Message for Foo {}`
	`25`	`+impl Foo {`
`25`	`26`	`pub fn alloc() -> Self {`
`26`	`27`	`Self(unsafe { msg_send!(objc::class!(Foo), alloc) })`
`27`	`28`	`}`
`28`	`29`	`}`
`29`		`-impl<ObjectType: 'static> interface_Foo<ObjectType> for struct_Foo {}`
`30`		`-pub trait interface_Foo<ObjectType>: Sized + std::ops::Deref {`
	`30`	`+impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}`
	`31`	`+pub trait IFoo<ObjectType>: Sized + std::ops::Deref {`
`31`	`32`	`unsafe fn get(self) -> u64`
`32`	`33`	`where`
`33`	`34`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`@@ -36,24 +37,25 @@ pub trait interface_Foo<ObjectType>: Sized + std::ops::Deref {`
`36`	`37`	`}`
`37`	`38`	`}`
`38`	`39`	`#[repr(transparent)]`
`39`		`-pub struct struct_FooMultiGeneric(pub id);`
`40`		`-impl std::ops::Deref for struct_FooMultiGeneric {`
	`40`	`+#[derive(Clone, Copy)]`
	`41`	`+pub struct FooMultiGeneric(pub id);`
	`42`	`+impl std::ops::Deref for FooMultiGeneric {`
`41`	`43`	`type Target = objc::runtime::Object;`
`42`	`44`	`fn deref(&self) -> &Self::Target {`
`43`	`45`	`unsafe { &*self.0 }`
`44`	`46`	`}`
`45`	`47`	`}`
`46`		`-unsafe impl objc::Message for struct_FooMultiGeneric {}`
`47`		`-impl struct_FooMultiGeneric {`
	`48`	`+unsafe impl objc::Message for FooMultiGeneric {}`
	`49`	`+impl FooMultiGeneric {`
`48`	`50`	`pub fn alloc() -> Self {`
`49`	`51`	`Self(unsafe { msg_send!(objc::class!(FooMultiGeneric), alloc) })`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`	`impl<KeyType: 'static, ObjectType: 'static>`
`53`		`- interface_FooMultiGeneric<KeyType, ObjectType> for struct_FooMultiGeneric`
	`55`	`+ IFooMultiGeneric<KeyType, ObjectType> for FooMultiGeneric`
`54`	`56`	`{`
`55`	`57`	`}`
`56`		`-pub trait interface_FooMultiGeneric<KeyType, ObjectType>:`
	`58`	`+pub trait IFooMultiGeneric<KeyType, ObjectType>:`
`57`	`59`	`Sized + std::ops::Deref`
`58`	`60`	`{`
`59`	`61`	`unsafe fn objectForKey_(self, key: u64) -> u64`
Original file line number	Diff line number	Diff line change
`@@ -13,29 +13,30 @@ extern crate objc;`
`13`	`13`	`#[allow(non_camel_case_types)]`
`14`	`14`	`pub type id = *mut objc::runtime::Object;`
`15`	`15`	`#[repr(transparent)]`
`16`		`-pub struct struct_Foo(pub id);`
`17`		`-impl std::ops::Deref for struct_Foo {`
	`16`	`+#[derive(Clone, Copy)]`
	`17`	`+pub struct Foo(pub id);`
	`18`	`+impl std::ops::Deref for Foo {`
`18`	`19`	`type Target = objc::runtime::Object;`
`19`	`20`	`fn deref(&self) -> &Self::Target {`
`20`	`21`	`unsafe { &*self.0 }`
`21`	`22`	`}`
`22`	`23`	`}`
`23`		`-unsafe impl objc::Message for struct_Foo {}`
`24`		`-impl struct_Foo {`
	`24`	`+unsafe impl objc::Message for Foo {}`
	`25`	`+impl Foo {`
`25`	`26`	`pub fn alloc() -> Self {`
`26`	`27`	`Self(unsafe { msg_send!(objc::class!(Foo), alloc) })`
`27`	`28`	`}`
`28`	`29`	`}`
`29`		`-impl interface_Foo for struct_Foo {}`
`30`		`-pub trait interface_Foo: Sized + std::ops::Deref {`
	`30`	`+impl IFoo for Foo {}`
	`31`	`+pub trait IFoo: Sized + std::ops::Deref {`
`31`	`32`	`unsafe fn method(self)`
`32`	`33`	`where`
`33`	`34`	`<Self as std::ops::Deref>::Target: objc::Message + Sized,`
`34`	`35`	`{`
`35`	`36`	`msg_send!(self, method)`
`36`	`37`	`}`
`37`	`38`	`}`
`38`		`-impl Foo_BarCategory for struct_Foo {}`
	`39`	`+impl Foo_BarCategory for Foo {}`
`39`	`40`	`pub trait Foo_BarCategory: Sized + std::ops::Deref {`
`40`	`41`	`unsafe fn categoryMethod(self)`
`41`	`42`	`where`