openpgp-ffi: Use wrapper types.

  - With the abstractions for moving ownership and references across
    the FFI boundary, we can now switch to actually using the wrapper
    types by changing the function signatures to use the wrapper type,
    and updating the generated functions.

5 files changed, 64 insertions, 57 deletions

diff --git a/ffi-macros/src/lib.rs b/ffi-macros/src/lib.rs
index 131acfeb..1f57275b 100644
--- a/ffi-macros/src/lib.rs
+++ b/ffi-macros/src/lib.rs
@@ -178,7 +178,8 @@ pub fn ffi_wrapper_type(args: TokenStream, input: TokenStream) -> TokenStream {
     ];
     let mut impls = TokenStream2::new();
     for dfn in derive.into_iter().chain(default_derives.iter()) {
-        impls.extend(dfn(st.span(), &prefix, &name, &wrapped_type, &wrapped_type));
+        impls.extend(dfn(st.span(), &prefix, &name,
+                         &st.ident, &wrapped_type));
     }
 
     let expanded = quote! {
@@ -219,7 +220,7 @@ fn ident2c_tests() {
 }
 
 /// Describes our custom derive functions.
-type DeriveFn = fn(proc_macro2::Span, &str, &str, &syn::Type, &syn::Type)
+type DeriveFn = fn(proc_macro2::Span, &str, &str, &syn::Ident, &syn::Type)
                    -> TokenStream2;
 
 /// Maps trait names to our generator functions.
@@ -241,35 +242,41 @@ fn derive_functions() -> &'static HashMap<&'static str, DeriveFn>
 
 /// Derives prefix_name_conversion_trait.
 fn derive_conversion_traits(_: proc_macro2::Span, _: &str, _: &str,
-                            wrapper: &syn::Type, wrapped: &syn::Type)
+                            wrapper: &syn::Ident, wrapped: &syn::Type)
                             -> TokenStream2
 {
     quote! {
         use MoveFromRaw;
         impl MoveFromRaw<#wrapped> for *mut #wrapper {
             fn move_from_raw(self) -> #wrapped {
-                *ffi_param_move!(self)
+                ffi_param_move!(self).0
             }
         }
 
         use RefRaw;
         impl RefRaw<#wrapped> for *const #wrapper {
             fn ref_raw(self) -> &'static #wrapped {
-                ffi_param_ref!(self)
+                &ffi_param_ref!(self).0
             }
         }
 
         use RefMutRaw;
         impl RefMutRaw<#wrapped> for *mut #wrapper {
             fn ref_mut_raw(self) -> &'static mut #wrapped {
-                ffi_param_ref_mut!(self)
+                &mut ffi_param_ref_mut!(self).0
+            }
+        }
+
+        impl #wrapper {
+            fn wrap(obj: #wrapped) -> *mut #wrapper {
+                Box::into_raw(Box::new(#wrapper(obj)))
             }
         }
 
         use MoveIntoRaw;
         impl MoveIntoRaw<*mut #wrapper> for #wrapped {
             fn move_into_raw(self) -> *mut #wrapper {
-                Box::into_raw(Box::new(self))
+                #wrapper::wrap(self)
             }
         }
 
@@ -278,7 +285,7 @@ fn derive_conversion_traits(_: proc_macro2::Span, _: &str, _: &str,
         {
             fn move_into_raw(self) -> Option<::std::ptr::NonNull<#wrapper>> {
                 self.map(|mut v| {
-                    let ptr = Box::into_raw(Box::new(v));
+                    let ptr = #wrapper::wrap(v);
                     ::std::ptr::NonNull::new(ptr).unwrap()
                 })
             }
@@ -292,7 +299,7 @@ fn derive_conversion_traits(_: proc_macro2::Span, _: &str, _: &str,
                              -> Option<::std::ptr::NonNull<#wrapper>> {
                 match self {
                     Ok(v) => {
-                        let ptr = Box::into_raw(Box::new(v));
+                        let ptr = #wrapper::wrap(v);
                         Some(::std::ptr::NonNull::new(ptr).unwrap())
                     },
                     Err(e) => {
@@ -309,7 +316,7 @@ fn derive_conversion_traits(_: proc_macro2::Span, _: &str, _: &str,
 
 /// Derives prefix_name_free.
 fn derive_free(span: proc_macro2::Span, prefix: &str, name: &str,
-               wrapper: &syn::Type, _wrapped: &syn::Type)
+               wrapper: &syn::Ident, _wrapped: &syn::Type)
                -> TokenStream2
 {
     let ident = syn::Ident::new(&format!("{}{}_free", prefix, name),
@@ -327,7 +334,7 @@ fn derive_free(span: proc_macro2::Span, prefix: &str, name: &str,
 
 /// Derives prefix_name_clone.
 fn derive_clone(span: proc_macro2::Span, prefix: &str, name: &str,
-                wrapper: &syn::Type, _wrapped: &syn::Type)
+                wrapper: &syn::Ident, _wrapped: &syn::Type)
                 -> TokenStream2
 {
     let ident = syn::Ident::new(&format!("{}{}_clone", prefix, name),
@@ -344,7 +351,7 @@ fn derive_clone(span: proc_macro2::Span, prefix: &str, name: &str,
 
 /// Derives prefix_name_equal.
 fn derive_equal(span: proc_macro2::Span, prefix: &str, name: &str,
-                wrapper: &syn::Type, _wrapped: &syn::Type)
+                wrapper: &syn::Ident, _wrapped: &syn::Type)
                 -> TokenStream2
 {
     let ident = syn::Ident::new(&format!("{}{}_equal", prefix, name),
@@ -363,7 +370,7 @@ fn derive_equal(span: proc_macro2::Span, prefix: &str, name: &str,
 
 /// Derives prefix_name_to_string.
 fn derive_to_string(span: proc_macro2::Span, prefix: &str, name: &str,
-                    wrapper: &syn::Type, _wrapped: &syn::Type)
+                    wrapper: &syn::Ident, _wrapped: &syn::Type)
                     -> TokenStream2
 {
     let ident = syn::Ident::new(&format!("{}{}_to_string", prefix, name),
@@ -381,7 +388,7 @@ fn derive_to_string(span: proc_macro2::Span, prefix: &str, name: &str,
 
 /// Derives prefix_name_debug.
 fn derive_debug(span: proc_macro2::Span, prefix: &str, name: &str,
-                wrapper: &syn::Type, _wrapped: &syn::Type)
+                wrapper: &syn::Ident, _wrapped: &syn::Type)
                 -> TokenStream2
 {
     let ident = syn::Ident::new(&format!("{}{}_debug", prefix, name),
@@ -399,7 +406,7 @@ fn derive_debug(span: proc_macro2::Span, prefix: &str, name: &str,
 
 /// Derives prefix_name_hash.
 fn derive_hash(span: proc_macro2::Span, prefix: &str, name: &str,
-               wrapper: &syn::Type, _wrapped: &syn::Type)
+               wrapper: &syn::Ident, _wrapped: &syn::Type)
                -> TokenStream2
 {
     let ident = syn::Ident::new(&format!("{}{}_hash", prefix, name),
diff --git a/openpgp-ffi/src/fingerprint.rs b/openpgp-ffi/src/fingerprint.rs
index f75e8235..07dabf2c 100644
--- a/openpgp-ffi/src/fingerprint.rs
+++ b/openpgp-ffi/src/fingerprint.rs
@@ -14,7 +14,7 @@ use std::slice;
 use libc::{uint8_t, c_char, size_t};
 
 extern crate sequoia_openpgp as openpgp;
-use self::openpgp::KeyID;
+use super::keyid::KeyID;
 use Maybe;
 
 /// Holds a fingerprint.
@@ -36,7 +36,7 @@ pub struct Fingerprint(openpgp::Fingerprint);
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_fingerprint_from_bytes(buf: *const uint8_t,
                               len: size_t)
-                              -> *mut openpgp::Fingerprint {
+                              -> *mut Fingerprint {
     assert!(!buf.is_null());
     let buf = unsafe {
         slice::from_raw_parts(buf, len as usize)
@@ -66,7 +66,7 @@ fn pgp_fingerprint_from_bytes(buf: *const uint8_t,
 /// ```
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_fingerprint_from_hex(hex: *const c_char)
-                            -> Maybe<openpgp::Fingerprint> {
+                            -> Maybe<Fingerprint> {
     let hex = ffi_param_cstr!(hex).to_string_lossy();
     openpgp::Fingerprint::from_hex(&hex).ok().move_into_raw()
 }
@@ -76,7 +76,7 @@ fn pgp_fingerprint_from_hex(hex: *const c_char)
 /// This returns a reference to the internal buffer that is valid as
 /// long as the fingerprint is.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_fingerprint_as_bytes(fp: *const openpgp::Fingerprint,
+fn pgp_fingerprint_as_bytes(fp: *const Fingerprint,
                             fp_len: Option<&mut size_t>)
                             -> *const uint8_t {
     let fp = fp.ref_raw();
@@ -88,14 +88,14 @@ fn pgp_fingerprint_as_bytes(fp: *const openpgp::Fingerprint,
 
 /// Converts the fingerprint to a hexadecimal number.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_fingerprint_to_hex(fp: *const openpgp::Fingerprint)
+fn pgp_fingerprint_to_hex(fp: *const Fingerprint)
                           -> *mut c_char {
     ffi_return_string!(fp.ref_raw().to_hex())
 }
 
 /// Converts the fingerprint to a key ID.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_fingerprint_to_keyid(fp: *const openpgp::Fingerprint)
+fn pgp_fingerprint_to_keyid(fp: *const Fingerprint)
                             -> *mut KeyID {
     fp.ref_raw().to_keyid().move_into_raw()
 }
diff --git a/openpgp-ffi/src/keyid.rs b/openpgp-ffi/src/keyid.rs
index 96df52ca..7236da89 100644
--- a/openpgp-ffi/src/keyid.rs
+++ b/openpgp-ffi/src/keyid.rs
@@ -51,7 +51,7 @@ pub struct KeyID(openpgp::KeyID);
 /// free (mr_b_as_string);
 /// ```
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_keyid_from_bytes(id: *const uint8_t) -> *mut openpgp::KeyID {
+fn pgp_keyid_from_bytes(id: *const uint8_t) -> *mut KeyID {
     assert!(!id.is_null());
     let id = unsafe { slice::from_raw_parts(id, 8) };
     openpgp::KeyID::from_bytes(id).move_into_raw()
@@ -76,13 +76,13 @@ fn pgp_keyid_from_bytes(id: *const uint8_t) -> *mut openpgp::KeyID {
 /// pgp_keyid_free (mr_b);
 /// ```
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_keyid_from_hex(id: *const c_char) -> Maybe<openpgp::KeyID> {
+fn pgp_keyid_from_hex(id: *const c_char) -> Maybe<KeyID> {
     let id = ffi_param_cstr!(id).to_string_lossy();
     openpgp::KeyID::from_hex(&id).ok().move_into_raw()
 }
 
 /// Converts the KeyID to a hexadecimal number.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_keyid_to_hex(id: *const openpgp::KeyID) -> *mut c_char {
+fn pgp_keyid_to_hex(id: *const KeyID) -> *mut c_char {
     ffi_return_string!(id.ref_raw().to_hex())
 }
diff --git a/openpgp-ffi/src/packet_pile.rs b/openpgp-ffi/src/packet_pile.rs
index c379a8e8..326aeafb 100644
--- a/openpgp-ffi/src/packet_pile.rs
+++ b/openpgp-ffi/src/packet_pile.rs
@@ -40,7 +40,7 @@ pub struct PacketPile(openpgp::PacketPile);
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_packet_pile_from_reader(errp: Option<&mut *mut failure::Error>,
                                reader: *mut Box<Read>)
-                               -> Maybe<openpgp::PacketPile> {
+                               -> Maybe<PacketPile> {
     let reader = ffi_param_ref_mut!(reader);
     openpgp::PacketPile::from_reader(reader).move_into_raw(errp)
 }
@@ -52,7 +52,7 @@ fn pgp_packet_pile_from_reader(errp: Option<&mut *mut failure::Error>,
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_packet_pile_from_file(errp: Option<&mut *mut failure::Error>,
                              filename: *const c_char)
-                             -> Maybe<openpgp::PacketPile> {
+                             -> Maybe<PacketPile> {
     let filename = ffi_param_cstr!(filename).to_string_lossy().into_owned();
     openpgp::PacketPile::from_file(&filename).move_into_raw(errp)
 }
@@ -63,7 +63,7 @@ fn pgp_packet_pile_from_file(errp: Option<&mut *mut failure::Error>,
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_packet_pile_from_bytes(errp: Option<&mut *mut failure::Error>,
                               b: *const uint8_t, len: size_t)
-                              -> Maybe<openpgp::PacketPile> {
+                              -> Maybe<PacketPile> {
     assert!(!b.is_null());
     let buf = unsafe {
         slice::from_raw_parts(b, len as usize)
@@ -75,7 +75,7 @@ fn pgp_packet_pile_from_bytes(errp: Option<&mut *mut failure::Error>,
 /// Serializes the packet pile.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_packet_pile_serialize(errp: Option<&mut *mut failure::Error>,
-                             packet_pile: *const openpgp::PacketPile,
+                             packet_pile: *const PacketPile,
                              writer: *mut Box<Write>)
                              -> Status {
     ffi_make_fry_from_errp!(errp);
diff --git a/openpgp-ffi/src/tpk.rs b/openpgp-ffi/src/tpk.rs
index a013dcae..a3df23b7 100644
--- a/openpgp-ffi/src/tpk.rs
+++ b/openpgp-ffi/src/tpk.rs
@@ -60,7 +60,7 @@ pub struct TPK(openpgp::TPK);
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_from_reader(errp: Option<&mut *mut failure::Error>,
                        reader: *mut Box<Read>)
-                       -> Maybe<openpgp::TPK> {
+                       -> Maybe<TPK> {
     let reader = ffi_param_ref_mut!(reader);
     openpgp::TPK::from_reader(reader).move_into_raw(errp)
 }
@@ -69,7 +69,7 @@ fn pgp_tpk_from_reader(errp: Option<&mut *mut failure::Error>,
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_from_file(errp: Option<&mut *mut failure::Error>,
                      filename: *const c_char)
-                     -> Maybe<openpgp::TPK> {
+                     -> Maybe<TPK> {
     let filename = ffi_param_cstr!(filename).to_string_lossy().into_owned();
     openpgp::TPK::from_file(&filename).move_into_raw(errp)
 }
@@ -80,7 +80,7 @@ fn pgp_tpk_from_file(errp: Option<&mut *mut failure::Error>,
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_from_packet_pile(errp: Option<&mut *mut failure::Error>,
                             m: *mut PacketPile)
-                            -> Maybe<openpgp::TPK> {
+                            -> Maybe<TPK> {
     let m = ffi_param_move!(m);
     openpgp::TPK::from_packet_pile(*m).move_into_raw(errp)
 }
@@ -91,7 +91,7 @@ fn pgp_tpk_from_packet_pile(errp: Option<&mut *mut failure::Error>,
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_from_bytes(errp: Option<&mut *mut failure::Error>,
                       b: *const uint8_t, len: size_t)
-                      -> Maybe<openpgp::TPK> {
+                      -> Maybe<TPK> {
     assert!(!b.is_null());
     let buf = unsafe {
         slice::from_raw_parts(b, len as usize)
@@ -106,7 +106,7 @@ fn pgp_tpk_from_bytes(errp: Option<&mut *mut failure::Error>,
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_from_packet_parser(errp: Option<&mut *mut failure::Error>,
                               ppr: *mut PacketParserResult)
-                              -> Maybe<openpgp::TPK>
+                              -> Maybe<TPK>
 {
     let ppr = ffi_param_move!(ppr);
 
@@ -116,7 +116,7 @@ fn pgp_tpk_from_packet_parser(errp: Option<&mut *mut failure::Error>,
 /// Serializes the TPK.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_serialize(errp: Option<&mut *mut failure::Error>,
-                     tpk: *const openpgp::TPK,
+                     tpk: *const TPK,
                      writer: *mut Box<Write>)
                      -> Status {
     ffi_make_fry_from_errp!(errp);
@@ -133,9 +133,9 @@ fn pgp_tpk_serialize(errp: Option<&mut *mut failure::Error>,
 /// Consumes `tpk` and `other`.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_merge(errp: Option<&mut *mut failure::Error>,
-                 tpk: *mut openpgp::TPK,
-                 other: *mut openpgp::TPK)
-                 -> Maybe<openpgp::TPK> {
+                 tpk: *mut TPK,
+                 other: *mut TPK)
+                 -> Maybe<TPK> {
     let tpk = tpk.move_from_raw();
     let other = other.move_from_raw();
     tpk.merge(other).move_into_raw(errp)
@@ -150,10 +150,10 @@ fn pgp_tpk_merge(errp: Option<&mut *mut failure::Error>,
 /// must be managed by the caller.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_merge_packets(errp: Option<&mut *mut failure::Error>,
-                         tpk: *mut openpgp::TPK,
+                         tpk: *mut TPK,
                          packets: *mut *mut Packet,
                          packets_len: size_t)
-                         -> Maybe<openpgp::TPK> {
+                         -> Maybe<TPK> {
     let tpk = tpk.move_from_raw();
     let packets = unsafe {
         slice::from_raw_parts_mut(packets, packets_len)
@@ -165,7 +165,7 @@ fn pgp_tpk_merge_packets(errp: Option<&mut *mut failure::Error>,
 
 /// Returns the fingerprint.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_fingerprint(tpk: *const openpgp::TPK)
+fn pgp_tpk_fingerprint(tpk: *const TPK)
                        -> *mut Fingerprint {
     let tpk = tpk.ref_raw();
     tpk.fingerprint().move_into_raw()
@@ -174,7 +174,7 @@ fn pgp_tpk_fingerprint(tpk: *const openpgp::TPK)
 /// Cast the public key into a secret key that allows using the secret
 /// parts of the containing keys.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_into_tsk(tpk: *mut openpgp::TPK)
+fn pgp_tpk_into_tsk(tpk: *mut TPK)
                     -> *mut TSK {
     let tpk = tpk.move_from_raw();
     box_raw!(tpk.into_tsk())
@@ -185,7 +185,7 @@ fn pgp_tpk_into_tsk(tpk: *mut openpgp::TPK)
 /// The tpk still owns the key.  The caller should neither modify nor
 /// free the key.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_primary(tpk: *const openpgp::TPK)
+fn pgp_tpk_primary(tpk: *const TPK)
                    -> *const packet::Key {
     let tpk = tpk.ref_raw();
     tpk.primary()
@@ -197,7 +197,7 @@ fn pgp_tpk_primary(tpk: *const openpgp::TPK)
 /// not reflect whether an individual user id, user attribute or
 /// subkey has been revoked.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_revocation_status(tpk: *const openpgp::TPK)
+fn pgp_tpk_revocation_status(tpk: *const TPK)
                              -> *mut RevocationStatus<'static> {
     let tpk = tpk.ref_raw();
     box_raw!(tpk.revoked(None))
@@ -264,7 +264,7 @@ fn int_to_reason_for_revocation(code: c_int) -> ReasonForRevocation {
 /// ```
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_revoke(errp: Option<&mut *mut failure::Error>,
-                  tpk: *const openpgp::TPK,
+                  tpk: *const TPK,
                   primary_signer: *mut Box<crypto::Signer>,
                   code: c_int,
                   reason: Option<&c_char>)
@@ -327,11 +327,11 @@ fn pgp_tpk_revoke(errp: Option<&mut *mut failure::Error>,
 /// ```
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_revoke_in_place(errp: Option<&mut *mut failure::Error>,
-                           tpk: *mut openpgp::TPK,
+                           tpk: *mut TPK,
                            primary_signer: *mut Box<crypto::Signer>,
                            code: c_int,
                            reason: Option<&c_char>)
-                           -> Maybe<openpgp::TPK>
+                           -> Maybe<TPK>
 {
     let tpk = tpk.move_from_raw();
     let signer = ffi_param_ref_mut!(primary_signer);
@@ -347,7 +347,7 @@ fn pgp_tpk_revoke_in_place(errp: Option<&mut *mut failure::Error>,
 
 /// Returns whether the TPK has expired.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_expired(tpk: *const openpgp::TPK)
+fn pgp_tpk_expired(tpk: *const TPK)
                    -> c_int {
     let tpk = tpk.ref_raw();
 
@@ -356,7 +356,7 @@ fn pgp_tpk_expired(tpk: *const openpgp::TPK)
 
 /// Returns whether the TPK has expired.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_expired_at(tpk: *const openpgp::TPK, when: time_t)
+fn pgp_tpk_expired_at(tpk: *const TPK, when: time_t)
                       -> c_int {
     let tpk = tpk.ref_raw();
     tpk.expired_at(time::at(time::Timespec::new(when as i64, 0))) as c_int
@@ -364,7 +364,7 @@ fn pgp_tpk_expired_at(tpk: *const openpgp::TPK, when: time_t)
 
 /// Returns whether the TPK is alive.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_alive(tpk: *const openpgp::TPK)
+fn pgp_tpk_alive(tpk: *const TPK)
                  -> c_int {
     let tpk = tpk.ref_raw();
 
@@ -373,7 +373,7 @@ fn pgp_tpk_alive(tpk: *const openpgp::TPK)
 
 /// Returns whether the TPK is alive at the specified time.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_alive_at(tpk: *const openpgp::TPK, when: time_t)
+fn pgp_tpk_alive_at(tpk: *const TPK, when: time_t)
                     -> c_int {
     let tpk = tpk.ref_raw();
     tpk.alive_at(time::at(time::Timespec::new(when as i64, 0))) as c_int
@@ -387,8 +387,8 @@ fn pgp_tpk_alive_at(tpk: *const openpgp::TPK, when: time_t)
 /// This function consumes `tpk` and returns a new `TPK`.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
 fn pgp_tpk_set_expiry(errp: Option<&mut *mut failure::Error>,
-                      tpk: *mut openpgp::TPK, expiry: u32)
-                      -> Maybe<openpgp::TPK> {
+                      tpk: *mut TPK, expiry: u32)
+                      -> Maybe<TPK> {
     let tpk = tpk.move_from_raw();
 
     tpk.set_expiry_in_seconds(expiry).move_into_raw(errp)
@@ -396,7 +396,7 @@ fn pgp_tpk_set_expiry(errp: Option<&mut *mut failure::Error>,
 
 /// Returns whether the TPK includes any secret key material.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_is_tsk(tpk: *const openpgp::TPK)
+fn pgp_tpk_is_tsk(tpk: *const TPK)
                   -> c_int {
     let tpk = tpk.ref_raw();
     tpk.is_tsk() as c_int
@@ -404,7 +404,7 @@ fn pgp_tpk_is_tsk(tpk: *const openpgp::TPK)
 
 /// Returns an iterator over the TPK's user id bindings.
 #[::ffi_catch_abort] #[no_mangle] pub extern "system"
-fn pgp_tpk_primary_user_id(tpk: *const openpgp::TPK)
+fn pgp_tpk_primary_user_id(tpk: *const TPK)
                            -> *mut c_char
 {
     let tpk = tpk.ref_raw();
@@ -449,7 +449,7 @@ pub extern "system" fn pgp_user_id_binding_selfsig(
 
 /// Returns an iterator over the TPK's user id bindings.
 #[::ffi_catch_abort] #[no_mangle]
-pub extern "system" fn pgp_tpk_user_id_binding_iter(tpk: *const openpgp::TPK)
+pub extern "system" fn pgp_tpk_user_id_binding_iter(tpk: *const TPK)
     -> *mut UserIDBindingIter<'static>
 {
     let tpk = tpk.ref_raw();
@@ -486,7 +486,7 @@ pub struct KeyIterWrapper<'a> {
 ///
 /// This iterates over both the primary key and any subkeys.
 #[::ffi_catch_abort] #[no_mangle]
-pub extern "system" fn pgp_tpk_key_iter(tpk: *const openpgp::TPK)
+pub extern "system" fn pgp_tpk_key_iter(tpk: *const TPK)
     -> *mut KeyIterWrapper<'static>
 {
     let tpk = tpk.ref_raw();
@@ -657,7 +657,7 @@ pub extern "system" fn pgp_tpk_builder_add_certification_subkey
 #[::ffi_catch_abort] #[no_mangle]
 pub extern "system" fn pgp_tpk_builder_generate
     (errp: Option<&mut *mut failure::Error>, tpkb: *mut TPKBuilder,
-     tpk_out: *mut Maybe<openpgp::TPK>,
+     tpk_out: *mut Maybe<TPK>,
      revocation_out: *mut *mut Signature)
     -> Status
 {