Merge branch 'master' of github.com:rust-lang/rust-bindgen into objc-category-inheritance

Author: simlay

CHANGELOG.md

@@ -120,11 +120,11 @@ Released YYYY/MM/DD
 
 ## Added
 
-* TODO (or remove section if none)
+* Objective-c bindings generate `From<ChildClass> for ParentClass` as well as `TryFrom<ParentClass> for ChildClass` ([#1883][]).
 
 ## Changed
 
-* TODO (or remove section if none)
+* Objective-c bindings borrow self rather than take ownership ([#1883][]).
 
 ## Deprecated
 
@@ -136,12 +136,15 @@ Released YYYY/MM/DD
 
 ## Fixed
 
-* TODO (or remove section if none)
+* Fixed objective-c protocol impl blocks for parent classes's protocols ([#1883][]).
 
 ## Security
 
 * TODO (or remove section if none)
 
+
+[#1883]: https://github.com/rust-lang/rust-bindgen/issues/1883
+
 --------------------------------------------------------------------------------
 
 # 0.55.1

bindgen-integration/build.rs

@@ -1,8 +1,8 @@
 extern crate bindgen;
 extern crate cc;
 
-use bindgen::callbacks::{MacroParsingBehavior, ParseCallbacks, IntKind};
-use bindgen::Builder;
+use bindgen::callbacks::{IntKind, MacroParsingBehavior, ParseCallbacks};
+use bindgen::{Builder, EnumVariation};
 use std::collections::HashSet;
 use std::env;
 use std::path::PathBuf;
@@ -147,7 +147,9 @@ fn main() {
     let bindings = Builder::default()
         .rustfmt_bindings(false)
         .enable_cxx_namespaces()
-        .rustified_enum(".*")
+        .default_enum_style(EnumVariation::Rust {
+            non_exhaustive: false,
+        })
         .raw_line("pub use self::root::*;")
         .raw_line("extern { fn my_prefixed_function_to_remove(i: i32); }")
         .module_raw_line("root::testing", "pub type Bar = i32;")
@@ -159,6 +161,8 @@ fn main() {
             seen_funcs: Mutex::new(0),
         }))
         .blacklist_function("my_prefixed_function_to_remove")
+        .constified_enum("my_prefixed_enum_to_be_constified")
+        .opaque_type("my_prefixed_templated_foo<my_prefixed_baz>")
         .generate()
         .expect("Unable to generate bindings");
 

bindgen-integration/cpp/Test.cc

@@ -134,4 +134,4 @@ Seventh::assert(bool first,
 
 int my_prefixed_function_name() {
   return 4;
-}
+}

bindgen-integration/cpp/Test.h

@@ -210,4 +210,21 @@ struct my_prefixed_foo {
    my_prefixed_bar member;
 };
 
+enum my_prefixed_enum_to_be_constified {
+  ONE = 1,
+  TWO,
+  THREE,
+};
+
+struct my_prefixed_baz {
+  char foo[30];
+};
+
+template<typename T>
+struct my_prefixed_templated_foo {
+  T member;
+};
+
+my_prefixed_templated_foo<my_prefixed_baz> TEMPLATED_CONST_VALUE;
+
 void my_prefixed_function_to_remove();

bindgen-integration/src/lib.rs

@@ -245,6 +245,12 @@ fn test_item_rename() {
     };
 }
 
+#[test]
+fn test_matching_with_rename() {
+    assert_eq!(bindings::enum_to_be_constified_THREE, 3);
+    assert_eq!(unsafe { bindings::TEMPLATED_CONST_VALUE.len() }, 30);
+}
+
 #[test]
 fn test_macro_customintkind_path() {
     let v: &std::any::Any = &bindings::TESTMACRO_CUSTOMINTKIND_PATH;

csmith-fuzzing/predicate.py

@@ -80,6 +80,7 @@
 reducing.add_argument(
     "--bindings-grep",
     type=str,
+    nargs='*',
     help="Exit non-zero if the given regexp pattern is not found in the emitted bindings.")
 
 reducing.add_argument(
@@ -218,11 +219,11 @@ def run_bindgen(args, bindings):
     if not args.expect_bindgen_fail and child.returncode != 0:
         exit_1("Error: running `bindgen` failed", child)
 
-    if args.bindings_grep:
-        pattern = regexp(args.bindings_grep)
+    for arg in args.bindings_grep:
+        pattern = regexp(arg)
         with open(bindings, mode="r") as f:
             if not contains(pattern, f):
-                print("Error: expected the emitted bindings to contain '{}', but they didn't".format(args.bindings_grep))
+                print("Error: expected the emitted bindings to contain '{}', but they didn't".format(arg))
                 print("---------- {} ----------------------------------------------".format(bindings))
                 f.seek(0)
                 print(f.read())

src/codegen/mod.rs

@@ -239,7 +239,7 @@ impl<'a> CodegenResult<'a> {
             saw_objc: false,
             saw_block: false,
             saw_bitfield_unit: false,
-            codegen_id: codegen_id,
+            codegen_id,
             items_seen: Default::default(),
             functions_seen: Default::default(),
             vars_seen: Default::default(),
@@ -987,9 +987,9 @@ impl<'a> Vtable<'a> {
         base_classes: &'a [Base],
     ) -> Self {
         Vtable {
-            item_id: item_id,
-            methods: methods,
-            base_classes: base_classes,
+            item_id,
+            methods,
+            base_classes,
         }
     }
 }
@@ -3806,7 +3806,7 @@ fn objc_method_codegen(
         }
     } else {
         let fn_args = fn_args.clone();
-        let args = iter::once(quote! { self }).chain(fn_args.into_iter());
+        let args = iter::once(quote! { &self }).chain(fn_args.into_iter());
         quote! {
             ( #( #args ),* ) #fn_ret
         }
@@ -3825,7 +3825,7 @@ fn objc_method_codegen(
         }
     } else {
         quote! {
-            msg_send!(self, #methods_and_args)
+            msg_send!(*self, #methods_and_args)
         }
     };
 
@@ -3901,7 +3901,7 @@ impl CodeGenerator for ObjCInterface {
         if !self.is_category() && !self.is_protocol() {
             let struct_block = quote! {
                 #[repr(transparent)]
-                #[derive(Clone, Copy)]
+                #[derive(Clone)]
                 pub struct #class_name(pub id);
                 impl std::ops::Deref for #class_name {
                     type Target = objc::runtime::Object;
@@ -3921,7 +3921,9 @@ impl CodeGenerator for ObjCInterface {
                 }
             };
             result.push(struct_block);
+            let mut protocol_set: HashSet<ItemId> = Default::default();
             for protocol_id in self.conforms_to.iter() {
+                protocol_set.insert(*protocol_id);
                 let protocol_name = ctx.rust_ident(
                     ctx.resolve_type(protocol_id.expect_type_id(ctx))
                         .name()
@@ -3942,26 +3944,73 @@ impl CodeGenerator for ObjCInterface {
                     .expect_type()
                     .kind();
 
-                parent_class = if let TypeKind::ObjCInterface(ref parent) =
-                    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 {
+                let parent = match parent {
+                    TypeKind::ObjCInterface(ref parent) => parent,
+                    _ => break,
+                };
+                parent_class = parent.parent_class;
+
+                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);
+                for protocol_id in parent.conforms_to.iter() {
+                    if protocol_set.insert(*protocol_id) {
+                        let protocol_name = ctx.rust_ident(
+                            ctx.resolve_type(protocol_id.expect_type_id(ctx))
+                                .name()
+                                .unwrap(),
+                        );
+                        let impl_trait = quote! {
+                            impl #protocol_name for #class_name { }
+                        };
+                        result.push(impl_trait);
+                    }
+                }
+                if !parent.is_template() {
+                    let parent_struct_name = parent.name();
+                    let child_struct_name = self.name();
+                    let parent_struct = ctx.rust_ident(parent_struct_name);
+                    let from_block = quote! {
+                        impl From<#class_name> for #parent_struct {
+                            fn from(child: #class_name) -> #parent_struct {
+                                #parent_struct(child.0)
                             }
                         }
-                    } else {
-                        quote! {
-                            impl #parent_name for #class_name { }
+                    };
+                    result.push(from_block);
+
+                    let error_msg = format!(
+                        "This {} cannot be downcasted to {}",
+                        parent_struct_name, child_struct_name
+                    );
+                    let try_into_block = quote! {
+                        impl std::convert::TryFrom<#parent_struct> for #class_name {
+                            type Error = &'static str;
+                            fn try_from(parent: #parent_struct) -> Result<#class_name, Self::Error> {
+                                let is_kind_of : bool = unsafe { msg_send!(parent, isKindOfClass:class!(#class_name))};
+                                if is_kind_of {
+                                    Ok(#class_name(parent.0))
+                                } else {
+                                    Err(#error_msg)
+                                }
+                            }
                         }
                     };
-                    result.push(impl_trait);
+                    result.push(try_into_block);
                     for (category_name, category_template_names) in
                         &parent.categories
                     {

src/ir/enum_ty.rs

@@ -6,7 +6,6 @@ use super::item::Item;
 use super::ty::{Type, TypeKind};
 use crate::clang;
 use crate::ir::annotations::Annotations;
-use crate::ir::item::ItemCanonicalPath;
 use crate::parse::{ClangItemParser, ParseError};
 use crate::regex_set::RegexSet;
 
@@ -153,7 +152,7 @@ impl Enum {
         enums: &RegexSet,
         item: &Item,
     ) -> bool {
-        let path = item.canonical_path(ctx);
+        let path = item.path_for_whitelisting(ctx);
         let enum_ty = item.expect_type();
 
         if enums.matches(&path[1..].join("::")) {

src/ir/template.rs

@@ -28,7 +28,7 @@
 //! ```
 
 use super::context::{BindgenContext, ItemId, TypeId};
-use super::item::{IsOpaque, Item, ItemAncestors, ItemCanonicalPath};
+use super::item::{IsOpaque, Item, ItemAncestors};
 use super::traversal::{EdgeKind, Trace, Tracer};
 use crate::clang;
 use crate::parse::ClangItemParser;
@@ -306,12 +306,13 @@ impl IsOpaque for TemplateInstantiation {
         // correct fix is to make `canonical_{name,path}` include template
         // arguments properly.
 
-        let mut path = item.canonical_path(ctx);
+        let mut path = item.path_for_whitelisting(ctx).clone();
         let args: Vec<_> = self
             .template_arguments()
             .iter()
             .map(|arg| {
-                let arg_path = arg.canonical_path(ctx);
+                let arg_path =
+                    ctx.resolve_item(*arg).path_for_whitelisting(ctx);
                 arg_path[1..].join("::")
             })
             .collect();