Merge pull request #611 from dtolnay/lifetime

Emit lifetimes on extern type into Rust macro output

Author: dtolnay

gen/src/nested.rs

@@ -52,9 +52,10 @@ fn sort_by_inner_namespace(apis: Vec<&Api>, depth: usize) -> NamespaceEntries {
 mod tests {
     use super::NamespaceEntries;
     use crate::syntax::namespace::Namespace;
-    use crate::syntax::{Api, Doc, ExternType, Lang, Pair};
+    use crate::syntax::{Api, Doc, ExternType, Lang, Lifetimes, Pair};
     use proc_macro2::{Ident, Span};
     use std::iter::FromIterator;
+    use syn::punctuated::Punctuated;
     use syn::Token;
 
     #[test]
@@ -136,7 +137,11 @@ mod tests {
                 cxx: ident.clone(),
                 rust: ident,
             },
-            lifetimes: Vec::new(),
+            generics: Lifetimes {
+                lt_token: None,
+                lifetimes: Punctuated::new(),
+                gt_token: None,
+            },
             colon_token: None,
             bounds: Vec::new(),
             semi_token: Token![;](Span::call_site()),

macro/src/expand.rs

@@ -313,16 +313,23 @@ fn expand_enum(enm: &Enum) -> TokenStream {
 fn expand_cxx_type(ety: &ExternType) -> TokenStream {
     let ident = &ety.name.rust;
     let doc = &ety.doc;
+    let generics = &ety.generics;
     let type_id = type_id(&ety.name);
 
+    let lifetime_fields = ety.generics.lifetimes.iter().map(|lifetime| {
+        let field = format_ident!("_lifetime_{}", lifetime.ident);
+        quote!(#field: ::std::marker::PhantomData<&#lifetime ()>)
+    });
+
     quote! {
         #doc
         #[repr(C)]
-        pub struct #ident {
+        pub struct #ident #generics {
             _private: ::cxx::private::Opaque,
+            #(#lifetime_fields,)*
         }
 
-        unsafe impl ::cxx::ExternType for #ident {
+        unsafe impl #generics ::cxx::ExternType for #ident #generics {
             type Id = #type_id;
             type Kind = ::cxx::kind::Opaque;
         }
@@ -959,10 +966,11 @@ fn expand_rust_function_shim_super(
 fn expand_type_alias(alias: &TypeAlias) -> TokenStream {
     let doc = &alias.doc;
     let ident = &alias.name.rust;
+    let generics = &alias.generics;
     let ty = &alias.ty;
     quote! {
         #doc
-        pub type #ident = #ty;
+        pub type #ident #generics = #ty;
     }
 }
 

syntax/check.rs

@@ -337,7 +337,7 @@ fn check_api_type(cx: &mut Check, ety: &ExternType) {
         cx.error(derive, msg);
     }
 
-    if let Some(lifetime) = ety.lifetimes.first() {
+    if let Some(lifetime) = ety.generics.lifetimes.first() {
         cx.error(lifetime, "extern type with lifetimes is not supported yet");
     }
 
@@ -445,7 +445,7 @@ fn check_api_type_alias(cx: &mut Check, alias: &TypeAlias) {
         cx.error(derive, msg);
     }
 
-    if let Some(lifetime) = alias.lifetimes.first() {
+    if let Some(lifetime) = alias.generics.lifetimes.first() {
         cx.error(lifetime, "extern type with lifetimes is not supported yet");
     }
 }

syntax/mod.rs

@@ -74,7 +74,7 @@ pub struct ExternType {
     pub derives: Vec<Derive>,
     pub type_token: Token![type],
     pub name: Pair,
-    pub lifetimes: Vec<Lifetime>,
+    pub generics: Lifetimes,
     pub colon_token: Option<Token![:]>,
     pub bounds: Vec<Derive>,
     pub semi_token: Token![;],
@@ -116,7 +116,7 @@ pub struct TypeAlias {
     pub derives: Vec<Derive>,
     pub type_token: Token![type],
     pub name: Pair,
-    pub lifetimes: Vec<Lifetime>,
+    pub generics: Lifetimes,
     pub eq_token: Token![=],
     pub ty: RustType,
     pub semi_token: Token![;],
@@ -130,6 +130,12 @@ pub struct Impl {
     pub negative_token: Option<Token![!]>,
 }
 
+pub struct Lifetimes {
+    pub lt_token: Option<Token![<]>,
+    pub lifetimes: Punctuated<Lifetime, Token![,]>,
+    pub gt_token: Option<Token![>]>,
+}
+
 pub struct Signature {
     pub unsafety: Option<Token![unsafe]>,
     pub fn_token: Token![fn],

syntax/parse.rs

@@ -4,17 +4,17 @@ use crate::syntax::report::Errors;
 use crate::syntax::Atom::*;
 use crate::syntax::{
     attrs, error, Api, Array, Derive, Doc, Enum, ExternFn, ExternType, Impl, Include, IncludeKind,
-    Lang, Namespace, Pair, Receiver, Ref, RustName, Signature, SliceRef, Struct, Ty1, Type,
-    TypeAlias, Var, Variant,
+    Lang, Lifetimes, Namespace, Pair, Receiver, Ref, RustName, Signature, SliceRef, Struct, Ty1,
+    Type, TypeAlias, Var, Variant,
 };
 use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
 use quote::{format_ident, quote, quote_spanned};
 use syn::parse::{ParseStream, Parser};
 use syn::punctuated::Punctuated;
 use syn::{
     Abi, Attribute, Error, Expr, Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemType,
-    GenericArgument, GenericParam, Generics, Ident, ItemEnum, ItemImpl, ItemStruct, Lifetime, Lit,
-    LitStr, Pat, PathArguments, Result, ReturnType, Token, TraitBound, TraitBoundModifier,
+    GenericArgument, GenericParam, Generics, Ident, ItemEnum, ItemImpl, ItemStruct, Lit, LitStr,
+    Pat, PathArguments, Result, ReturnType, Token, TraitBound, TraitBoundModifier,
     Type as RustType, TypeArray, TypeBareFn, TypeParamBound, TypePath, TypeReference,
     Variant as RustVariant,
 };
@@ -385,7 +385,11 @@ fn parse_extern_type(
 
     let type_token = foreign_type.type_token;
     let name = pair(namespace, &foreign_type.ident, cxx_name, rust_name);
-    let lifetimes = Vec::new();
+    let generics = Lifetimes {
+        lt_token: None,
+        lifetimes: Punctuated::new(),
+        gt_token: None,
+    };
     let colon_token = None;
     let bounds = Vec::new();
     let semi_token = foreign_type.semi_token;
@@ -399,7 +403,7 @@ fn parse_extern_type(
         derives,
         type_token,
         name,
-        lifetimes,
+        generics,
         colon_token,
         bounds,
         semi_token,
@@ -581,17 +585,21 @@ fn parse_extern_verbatim(
         };
         let ident: Ident = input.parse()?;
         let generics: Generics = input.parse()?;
-        let mut lifetimes = Vec::new();
+        let mut lifetimes = Punctuated::new();
         let mut has_unsupported_generic_param = false;
-        for param in generics.params {
+        for pair in generics.params.into_pairs() {
+            let (param, punct) = pair.into_tuple();
             match param {
                 GenericParam::Lifetime(param) => {
                     if !param.bounds.is_empty() && !has_unsupported_generic_param {
                         let msg = "lifetime parameter with bounds is not supported yet";
                         cx.error(&param, msg);
                         has_unsupported_generic_param = true;
                     }
-                    lifetimes.push(param.lifetime);
+                    lifetimes.push_value(param.lifetime);
+                    if let Some(punct) = punct {
+                        lifetimes.push_punct(punct);
+                    }
                 }
                 GenericParam::Type(param) => {
                     if !has_unsupported_generic_param {
@@ -609,6 +617,11 @@ fn parse_extern_verbatim(
                 }
             }
         }
+        let lifetimes = Lifetimes {
+            lt_token: generics.lt_token,
+            lifetimes,
+            gt_token: generics.gt_token,
+        };
         let lookahead = input.lookahead1();
         if lookahead.peek(Token![=]) {
             // type Alias = crate::path::to::Type;
@@ -632,7 +645,7 @@ fn parse_type_alias(
     attrs: Vec<Attribute>,
     type_token: Token![type],
     ident: Ident,
-    lifetimes: Vec<Lifetime>,
+    generics: Lifetimes,
     input: ParseStream,
     lang: Lang,
     namespace: &Namespace,
@@ -672,7 +685,7 @@ fn parse_type_alias(
         derives,
         type_token,
         name,
-        lifetimes,
+        generics,
         eq_token,
         ty,
         semi_token,
@@ -684,7 +697,7 @@ fn parse_extern_type_bounded(
     attrs: Vec<Attribute>,
     type_token: Token![type],
     ident: Ident,
-    lifetimes: Vec<Lifetime>,
+    generics: Lifetimes,
     input: ParseStream,
     lang: Lang,
     trusted: bool,
@@ -752,7 +765,7 @@ fn parse_extern_type_bounded(
         derives,
         type_token,
         name,
-        lifetimes,
+        generics,
         colon_token,
         bounds,
         semi_token,

syntax/tokens.rs

@@ -1,7 +1,7 @@
 use crate::syntax::atom::Atom::*;
 use crate::syntax::{
-    Array, Atom, Derive, Enum, ExternFn, ExternType, Impl, Receiver, Ref, RustName, Signature,
-    SliceRef, Struct, Ty1, Type, TypeAlias, Var,
+    Array, Atom, Derive, Enum, ExternFn, ExternType, Impl, Lifetimes, Receiver, Ref, RustName,
+    Signature, SliceRef, Struct, Ty1, Type, TypeAlias, Var,
 };
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote_spanned, ToTokens};
@@ -157,6 +157,14 @@ impl ToTokens for Impl {
     }
 }
 
+impl ToTokens for Lifetimes {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.lt_token.to_tokens(tokens);
+        self.lifetimes.to_tokens(tokens);
+        self.gt_token.to_tokens(tokens);
+    }
+}
+
 impl ToTokens for Signature {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.fn_token.to_tokens(tokens);