Allow aliases and C++ opaque types to be trivial.

This change allows aliases:
  type Foo = bindgen::Bar;
and C++ opaque types:
  type Foo;
to declare that they're 'trivial' in the sense that:

* They have trivial move constructors
* They have no destructors

and therefore may be passed and owned by value in Rust.

A subsequent commit will add C++ static assertions.

This commit is a BREAKING CHANGE as it requires existing
ExternTypes to gain a new associated type

Author: adetaylor

macro/src/expand.rs

@@ -57,6 +57,10 @@ fn expand(ffi: Module, apis: &[Api], types: &Types) -> TokenStream {
             Api::TypeAlias(alias) => {
                 expanded.extend(expand_type_alias(alias));
                 hidden.extend(expand_type_alias_verify(namespace, alias));
+                let ident = &alias.ident;
+                if types.required_trivial_aliases.contains(ident) {
+                    hidden.extend(expand_type_alias_kind_trivial_verify(alias));
+                }
             }
         }
     }
@@ -179,6 +183,7 @@ fn expand_cxx_type(namespace: &Namespace, ety: &ExternType) -> TokenStream {
 
         unsafe impl ::cxx::ExternType for #ident {
             type Id = #type_id;
+            type Kind = ::cxx::Opaque;
         }
     }
 }
@@ -677,6 +682,18 @@ fn expand_type_alias_verify(namespace: &Namespace, alias: &TypeAlias) -> TokenSt
     }
 }
 
+fn expand_type_alias_kind_trivial_verify(type_alias: &TypeAlias) -> TokenStream {
+    let ident = &type_alias.ident;
+    let begin_span = type_alias.type_token.span;
+    let end_span = type_alias.semi_token.span;
+    let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_kind::<);
+    let end = quote_spanned!(end_span=> >);
+
+    quote! {
+        const _: fn() = #begin #ident, ::cxx::Trivial #end;
+    }
+}
+
 fn type_id(namespace: &Namespace, ident: &Ident) -> TokenStream {
     let mut path = String::new();
     for name in namespace {

src/extern_type.rs

@@ -104,7 +104,28 @@ pub unsafe trait ExternType {
     /// # }
     /// ```
     type Id;
+
+    /// Either `kind::Opaque` or `kind::Trivial`. If in doubt, use
+    /// `kind::Opaque`.
+    type Kind;
+}
+
+pub(crate) mod kind {
+
+    /// An opaque type which can't be passed or held by value within Rust.
+    /// For example, a C++ type with a destructor, or a non-trivial move
+    /// constructor. Rust's strict move semantics mean that we can't own
+    /// these by value in Rust, but they can still be owned by a
+    /// `UniquePtr`...
+    pub struct Opaque;
+
+    /// A type with trivial move constructors and no destructor, which
+    /// can therefore be owned and moved around in Rust code directly.
+    pub struct Trivial;
 }
 
 #[doc(hidden)]
 pub fn verify_extern_type<T: ExternType<Id = Id>, Id>() {}
+
+#[doc(hidden)]
+pub fn verify_extern_kind<T: ExternType<Kind = Kind>, Kind>() {}

src/lib.rs

@@ -396,6 +396,8 @@ pub use crate::cxx_string::CxxString;
 pub use crate::cxx_vector::CxxVector;
 pub use crate::exception::Exception;
 pub use crate::extern_type::ExternType;
+pub use crate::extern_type::kind::Opaque;
+pub use crate::extern_type::kind::Trivial;
 pub use crate::unique_ptr::UniquePtr;
 pub use cxxbridge_macro::bridge;
 
@@ -422,6 +424,7 @@ pub type Vector<T> = CxxVector<T>;
 #[doc(hidden)]
 pub mod private {
     pub use crate::cxx_vector::VectorElement;
+    pub use crate::extern_type::verify_extern_kind;
     pub use crate::extern_type::verify_extern_type;
     pub use crate::function::FatFunction;
     pub use crate::opaque::Opaque;

syntax/check.rs

@@ -338,6 +338,7 @@ fn is_unsized(cx: &mut Check, ty: &Type) -> bool {
         || cx.types.cxx.contains(ident)
             && !cx.types.structs.contains_key(ident)
             && !cx.types.enums.contains_key(ident)
+            && !cx.types.required_trivial_aliases.contains(ident)
         || cx.types.rust.contains(ident)
 }
 
@@ -376,7 +377,11 @@ fn describe(cx: &mut Check, ty: &Type) -> String {
             } else if cx.types.enums.contains_key(ident) {
                 "enum".to_owned()
             } else if cx.types.cxx.contains(ident) {
-                "C++ type".to_owned()
+                if cx.types.required_trivial_aliases.contains(ident) {
+                    "trivial C++ type".to_owned()
+                } else {
+                    "non-trivial C++ type".to_owned()
+                }
             } else if cx.types.rust.contains(ident) {
                 "opaque Rust type".to_owned()
             } else if Atom::from(ident) == Some(CxxString) {

syntax/types.rs

@@ -14,6 +14,7 @@ pub struct Types<'a> {
     pub rust: Set<&'a Ident>,
     pub aliases: Map<&'a Ident, &'a TypeAlias>,
     pub untrusted: Map<&'a Ident, &'a ExternType>,
+    pub required_trivial_aliases: Set<&'a Ident>,
 }
 
 impl<'a> Types<'a> {
@@ -135,6 +136,39 @@ impl<'a> Types<'a> {
             }
         }
 
+        // All these APIs may contain types passed by value. We need to ensure
+        // we check that this is permissible. We do this _after_ scanning all
+        // the APIs above, in case some function or struct references a type
+        // which is declared subsequently.
+        let mut required_trivial_aliases = Set::new();
+
+        fn insist_alias_types_are_trivial<'c>(required_trivial_aliases: &mut Set<&'c Ident>, aliases: &Map<&'c Ident, &'c TypeAlias>, ty: &'c Type) {
+            if let Type::Ident(ident) = ty {
+                if aliases.contains_key(ident) {
+                    required_trivial_aliases.insert(ident);
+                }
+            }
+        }
+
+        for api in apis {
+            match api {
+                Api::Struct(strct) => {
+                    for field in &strct.fields {
+                        insist_alias_types_are_trivial(&mut required_trivial_aliases, &aliases, &field.ty);
+                    }
+                },
+                Api::CxxFunction(efn) | Api::RustFunction(efn) => {
+                    for arg in &efn.args {
+                        insist_alias_types_are_trivial(&mut required_trivial_aliases, &aliases, &arg.ty);
+                    }
+                    if let Some(ret) = &efn.ret {
+                        insist_alias_types_are_trivial(&mut required_trivial_aliases, &aliases, &ret);
+                    }
+                },
+                _ => {}
+            }
+        }
+
         Types {
             all,
             structs,
@@ -143,6 +177,7 @@ impl<'a> Types<'a> {
             rust,
             aliases,
             untrusted,
+            required_trivial_aliases,
         }
     }