Merge pull request #334 from dtolnay/kind

Touch up PR 325

Author: dtolnay

macro/src/expand.rs

@@ -56,11 +56,7 @@ 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));
-                }
+                hidden.extend(expand_type_alias_verify(namespace, alias, types));
             }
         }
     }
@@ -671,29 +667,30 @@ fn expand_type_alias(alias: &TypeAlias) -> TokenStream {
     }
 }
 
-fn expand_type_alias_verify(namespace: &Namespace, alias: &TypeAlias) -> TokenStream {
+fn expand_type_alias_verify(
+    namespace: &Namespace,
+    alias: &TypeAlias,
+    types: &Types,
+) -> TokenStream {
     let ident = &alias.ident;
     let type_id = type_id(namespace, ident);
     let begin_span = alias.type_token.span;
     let end_span = alias.semi_token.span;
     let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_type::<);
     let end = quote_spanned!(end_span=> >);
 
-    quote! {
+    let mut verify = quote! {
         const _: fn() = #begin #ident, #type_id #end;
-    }
-}
-
-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::kind::Trivial #end;
+    if types.required_trivial_aliases.contains(&alias.ident) {
+        let begin = quote_spanned!(begin_span=> ::cxx::private::verify_extern_kind::<);
+        verify.extend(quote! {
+            const _: fn() = #begin #ident, ::cxx::kind::Trivial #end;
+        });
     }
+
+    verify
 }
 
 fn type_id(namespace: &Namespace, ident: &Ident) -> TokenStream {

src/lib.rs

@@ -422,8 +422,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::extern_type::{verify_extern_kind, verify_extern_type};
     pub use crate::function::FatFunction;
     pub use crate::opaque::Opaque;
     pub use crate::result::{r#try, Result};

syntax/types.rs

@@ -141,44 +141,26 @@ impl<'a> Types<'a> {
         // 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,
-        ) {
+        let mut insist_alias_types_are_trivial = |ty: &'a 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,
-                        );
+                        insist_alias_types_are_trivial(&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,
-                        );
+                        insist_alias_types_are_trivial(&arg.ty);
                     }
                     if let Some(ret) = &efn.ret {
-                        insist_alias_types_are_trivial(
-                            &mut required_trivial_aliases,
-                            &aliases,
-                            &ret,
-                        );
+                        insist_alias_types_are_trivial(&ret);
                     }
                 }
                 _ => {}