From c513242fb4246163bf6bf918e527eef86ce3057f Mon Sep 17 00:00:00 2001 From: Igor Gnatenko Date: Sun, 7 Oct 2018 08:46:24 +0200 Subject: [PATCH] initial import Signed-off-by: Igor Gnatenko --- .gitignore | 1 + 0001-Update-quote-and-proc-macro.patch | 1177 ++++++++++++++++++++++++ bindgen-fix-metadata.diff | 16 + rust-bindgen.spec | 91 ++ sources | 1 + 5 files changed, 1286 insertions(+) create mode 100644 .gitignore create mode 100644 0001-Update-quote-and-proc-macro.patch create mode 100644 bindgen-fix-metadata.diff create mode 100644 rust-bindgen.spec create mode 100644 sources diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e920d3e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/bindgen-0.42.0.crate diff --git a/0001-Update-quote-and-proc-macro.patch b/0001-Update-quote-and-proc-macro.patch new file mode 100644 index 0000000..bd2492e --- /dev/null +++ b/0001-Update-quote-and-proc-macro.patch @@ -0,0 +1,1177 @@ +From a71f3ec3e0960d1a52997603a06fa9cc4ad08c06 Mon Sep 17 00:00:00 2001 +From: Bastien Orivel +Date: Tue, 29 May 2018 12:33:02 +0200 +Subject: [PATCH] Update quote and proc-macro. + +I give up on the doc comments. This is a rebase of #1334 keeping the formatting +of the comments and using TokenStream::from_str instead because one can hope. + +Fixes #1407. +--- + src/codegen/helpers.rs | 65 +++++------ + src/codegen/impl_debug.rs | 16 +-- + src/codegen/impl_partialeq.rs | 9 +- + src/codegen/mod.rs | 202 +++++++++++++++++----------------- + src/codegen/struct_layout.rs | 11 +- + src/ir/context.rs | 10 +- + src/ir/function.rs | 4 +- + src/ir/objc.rs | 9 +- + src/lib.rs | 2 +- + 9 files changed, 158 insertions(+), 170 deletions(-) + +diff --git a/src/codegen/helpers.rs b/src/codegen/helpers.rs +index 343f1e30..e6274d84 100644 +--- a/src/codegen/helpers.rs ++++ b/src/codegen/helpers.rs +@@ -2,52 +2,48 @@ + + use ir::context::BindgenContext; + use ir::layout::Layout; +-use quote; +-use proc_macro2::{Term, Span}; ++use proc_macro2::{self, Ident, Span}; ++use quote::TokenStreamExt; + + pub mod attributes { +- use quote; +- use proc_macro2::{Term, Span}; ++ use proc_macro2::{self, Ident, Span}; + +- pub fn repr(which: &str) -> quote::Tokens { +- let which = Term::new(which, Span::call_site()); ++ pub fn repr(which: &str) -> proc_macro2::TokenStream { ++ let which = Ident::new(which, Span::call_site()); + quote! { + #[repr( #which )] + } + } + +- pub fn repr_list(which_ones: &[&str]) -> quote::Tokens { +- let which_ones = which_ones.iter().cloned().map(|one| Term::new(one, Span::call_site())); ++ pub fn repr_list(which_ones: &[&str]) -> proc_macro2::TokenStream { ++ let which_ones = which_ones.iter().cloned().map(|one| Ident::new(one, Span::call_site())); + quote! { + #[repr( #( #which_ones ),* )] + } + } + +- pub fn derives(which_ones: &[&str]) -> quote::Tokens { +- let which_ones = which_ones.iter().cloned().map(|one| Term::new(one, Span::call_site())); ++ pub fn derives(which_ones: &[&str]) -> proc_macro2::TokenStream { ++ let which_ones = which_ones.iter().cloned().map(|one| Ident::new(one, Span::call_site())); + quote! { + #[derive( #( #which_ones ),* )] + } + } + +- pub fn inline() -> quote::Tokens { ++ pub fn inline() -> proc_macro2::TokenStream { + quote! { + #[inline] + } + } + +- pub fn doc(comment: String) -> quote::Tokens { +- // Doc comments are already preprocessed into nice `///` formats by the +- // time they get here. Just make sure that we have newlines around it so +- // that nothing else gets wrapped into the comment. +- let mut tokens = quote! {}; +- tokens.append(Term::new("\n", Span::call_site())); +- tokens.append(Term::new(&comment, Span::call_site())); +- tokens.append(Term::new("\n", Span::call_site())); +- tokens ++ pub fn doc(comment: String) -> proc_macro2::TokenStream { ++ use std::str::FromStr; ++ ++ // NOTE(emilio): By this point comments are already preprocessed and in ++ // `///` form. Quote turns them into `#[doc]` comments, but oh well. ++ proc_macro2::TokenStream::from_str(&comment).unwrap() + } + +- pub fn link_name(name: &str) -> quote::Tokens { ++ pub fn link_name(name: &str) -> proc_macro2::TokenStream { + // LLVM mangles the name by default but it's already mangled. + // Prefixing the name with \u{1} should tell LLVM to not mangle it. + let name = format!("\u{1}{}", name); +@@ -59,7 +55,7 @@ pub mod attributes { + + /// Generates a proper type for a field or type with a given `Layout`, that is, + /// a type with the correct size and alignment restrictions. +-pub fn blob(ctx: &BindgenContext, layout: Layout) -> quote::Tokens { ++pub fn blob(ctx: &BindgenContext, layout: Layout) -> proc_macro2::TokenStream { + let opaque = layout.opaque(); + + // FIXME(emilio, #412): We fall back to byte alignment, but there are +@@ -74,7 +70,7 @@ pub fn blob(ctx: &BindgenContext, layout: Layout) -> quote::Tokens { + } + }; + +- let ty_name = Term::new(ty_name, Span::call_site()); ++ let ty_name = Ident::new(ty_name, Span::call_site()); + + let data_len = opaque.array_size(ctx).unwrap_or(layout.size); + +@@ -90,14 +86,14 @@ pub fn blob(ctx: &BindgenContext, layout: Layout) -> quote::Tokens { + } + + /// Integer type of the same size as the given `Layout`. +-pub fn integer_type(ctx: &BindgenContext, layout: Layout) -> Option { ++pub fn integer_type(ctx: &BindgenContext, layout: Layout) -> Option { + let name = Layout::known_type_for_size(ctx, layout.size)?; +- let name = Term::new(name, Span::call_site()); ++ let name = Ident::new(name, Span::call_site()); + Some(quote! { #name }) + } + + /// Generates a bitfield allocation unit type for a type with the given `Layout`. +-pub fn bitfield_unit(ctx: &BindgenContext, layout: Layout) -> quote::Tokens { ++pub fn bitfield_unit(ctx: &BindgenContext, layout: Layout) -> proc_macro2::TokenStream { + let mut tokens = quote! {}; + + if ctx.options().enable_cxx_namespaces { +@@ -124,10 +120,9 @@ pub mod ast_ty { + use ir::function::FunctionSig; + use ir::layout::Layout; + use ir::ty::FloatKind; +- use quote; + use proc_macro2; + +- pub fn raw_type(ctx: &BindgenContext, name: &str) -> quote::Tokens { ++ pub fn raw_type(ctx: &BindgenContext, name: &str) -> proc_macro2::TokenStream { + let ident = ctx.rust_ident_raw(name); + match ctx.options().ctypes_prefix { + Some(ref prefix) => { +@@ -146,7 +141,7 @@ pub mod ast_ty { + ctx: &BindgenContext, + fk: FloatKind, + layout: Option, +- ) -> quote::Tokens { ++ ) -> proc_macro2::TokenStream { + // TODO: we probably should take the type layout into account more + // often? + // +@@ -186,25 +181,25 @@ pub mod ast_ty { + } + } + +- pub fn int_expr(val: i64) -> quote::Tokens { ++ pub fn int_expr(val: i64) -> proc_macro2::TokenStream { + // Don't use quote! { #val } because that adds the type suffix. + let val = proc_macro2::Literal::i64_unsuffixed(val); + quote!(#val) + } + +- pub fn uint_expr(val: u64) -> quote::Tokens { ++ pub fn uint_expr(val: u64) -> proc_macro2::TokenStream { + // Don't use quote! { #val } because that adds the type suffix. + let val = proc_macro2::Literal::u64_unsuffixed(val); + quote!(#val) + } + +- pub fn byte_array_expr(bytes: &[u8]) -> quote::Tokens { ++ pub fn byte_array_expr(bytes: &[u8]) -> proc_macro2::TokenStream { + let mut bytes: Vec<_> = bytes.iter().cloned().collect(); + bytes.push(0); + quote! { [ #(#bytes),* ] } + } + +- pub fn cstr_expr(mut string: String) -> quote::Tokens { ++ pub fn cstr_expr(mut string: String) -> proc_macro2::TokenStream { + string.push('\0'); + let b = proc_macro2::Literal::byte_string(&string.as_bytes()); + quote! { +@@ -215,7 +210,7 @@ pub mod ast_ty { + pub fn float_expr( + ctx: &BindgenContext, + f: f64, +- ) -> Result { ++ ) -> Result { + if f.is_finite() { + let val = proc_macro2::Literal::f64_unsuffixed(f); + +@@ -249,7 +244,7 @@ pub mod ast_ty { + pub fn arguments_from_signature( + signature: &FunctionSig, + ctx: &BindgenContext, +- ) -> Vec { ++ ) -> Vec { + let mut unnamed_arguments = 0; + signature + .argument_types() +diff --git a/src/codegen/impl_debug.rs b/src/codegen/impl_debug.rs +index 8759bf27..d429e328 100644 +--- a/src/codegen/impl_debug.rs ++++ b/src/codegen/impl_debug.rs +@@ -3,14 +3,14 @@ use ir::context::BindgenContext; + use ir::derive::CanTriviallyDeriveDebug; + use ir::item::{HasTypeParamInArray, IsOpaque, Item, ItemCanonicalName}; + use ir::ty::{RUST_DERIVE_IN_ARRAY_LIMIT, TypeKind}; +-use quote; ++use proc_macro2; + + pub fn gen_debug_impl( + ctx: &BindgenContext, + fields: &[Field], + item: &Item, + kind: CompKind, +-) -> quote::Tokens { ++) -> proc_macro2::TokenStream { + let struct_name = item.canonical_name(ctx); + let mut format_string = format!("{} {{{{ ", struct_name); + let mut tokens = vec![]; +@@ -63,7 +63,7 @@ pub trait ImplDebug<'a> { + &self, + ctx: &BindgenContext, + extra: Self::Extra, +- ) -> Option<(String, Vec)>; ++ ) -> Option<(String, Vec)>; + } + + impl<'a> ImplDebug<'a> for FieldData { +@@ -73,7 +73,7 @@ impl<'a> ImplDebug<'a> for FieldData { + &self, + ctx: &BindgenContext, + _: Self::Extra, +- ) -> Option<(String, Vec)> { ++ ) -> Option<(String, Vec)> { + if let Some(name) = self.name() { + ctx.resolve_item(self.ty()).impl_debug(ctx, name) + } else { +@@ -89,7 +89,7 @@ impl<'a> ImplDebug<'a> for BitfieldUnit { + &self, + ctx: &BindgenContext, + _: Self::Extra, +- ) -> Option<(String, Vec)> { ++ ) -> Option<(String, Vec)> { + let mut format_string = String::new(); + let mut tokens = vec![]; + for (i, bitfield) in self.bitfields().iter().enumerate() { +@@ -118,7 +118,7 @@ impl<'a> ImplDebug<'a> for Item { + &self, + ctx: &BindgenContext, + name: &str, +- ) -> Option<(String, Vec)> { ++ ) -> Option<(String, Vec)> { + let name_ident = ctx.rust_ident(name); + + // We don't know if blacklisted items `impl Debug` or not, so we can't +@@ -136,8 +136,8 @@ impl<'a> ImplDebug<'a> for Item { + + fn debug_print( + name: &str, +- name_ident: quote::Tokens, +- ) -> Option<(String, Vec)> { ++ name_ident: proc_macro2::TokenStream, ++ ) -> Option<(String, Vec)> { + Some(( + format!("{}: {{:?}}", name), + vec![quote! { +diff --git a/src/codegen/impl_partialeq.rs b/src/codegen/impl_partialeq.rs +index c8ff6313..ca61b4bf 100644 +--- a/src/codegen/impl_partialeq.rs ++++ b/src/codegen/impl_partialeq.rs +@@ -3,7 +3,6 @@ use ir::comp::{CompInfo, CompKind, Field, FieldMethods}; + use ir::context::BindgenContext; + use ir::item::{IsOpaque, Item}; + use ir::ty::{TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT}; +-use quote; + use proc_macro2; + + /// Generate a manual implementation of `PartialEq` trait for the +@@ -12,8 +11,8 @@ pub fn gen_partialeq_impl( + ctx: &BindgenContext, + comp_info: &CompInfo, + item: &Item, +- ty_for_impl: "e::Tokens, +-) -> Option { ++ ty_for_impl: &proc_macro2::TokenStream, ++) -> Option { + let mut tokens = vec![]; + + if item.is_opaque(ctx, &()) { +@@ -71,8 +70,8 @@ pub fn gen_partialeq_impl( + }) + } + +-fn gen_field(ctx: &BindgenContext, ty_item: &Item, name: &str) -> quote::Tokens { +- fn quote_equals(name_ident: proc_macro2::Term) -> quote::Tokens { ++fn gen_field(ctx: &BindgenContext, ty_item: &Item, name: &str) -> proc_macro2::TokenStream { ++ fn quote_equals(name_ident: proc_macro2::Ident) -> proc_macro2::TokenStream { + quote! { self.#name_ident == other.#name_ident } + } + +diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs +index 91198701..de0375af 100644 +--- a/src/codegen/mod.rs ++++ b/src/codegen/mod.rs +@@ -37,8 +37,8 @@ use ir::template::{AsTemplateParam, TemplateInstantiation, TemplateParameters}; + use ir::ty::{Type, TypeKind}; + use ir::var::Var; + +-use quote; +-use proc_macro2::{self, Term, Span}; ++use quote::TokenStreamExt; ++use proc_macro2::{self, Ident, Span}; + + use std; + use std::borrow::Cow; +@@ -48,11 +48,12 @@ use std::collections::hash_map::{Entry, HashMap}; + use std::fmt::Write; + use std::iter; + use std::ops; ++use std::str::FromStr; + + // Name of type defined in constified enum module + pub static CONSTIFIED_ENUM_MODULE_REPR_NAME: &'static str = "Type"; + +-fn top_level_path(ctx: &BindgenContext, item: &Item) -> Vec { ++fn top_level_path(ctx: &BindgenContext, item: &Item) -> Vec { + let mut path = vec![quote! { self }]; + + if ctx.options().enable_cxx_namespaces { +@@ -64,7 +65,7 @@ fn top_level_path(ctx: &BindgenContext, item: &Item) -> Vec { + path + } + +-fn root_import(ctx: &BindgenContext, module: &Item) -> quote::Tokens { ++fn root_import(ctx: &BindgenContext, module: &Item) -> proc_macro2::TokenStream { + assert!(ctx.options().enable_cxx_namespaces, "Somebody messed it up"); + assert!(module.is_module()); + +@@ -76,7 +77,7 @@ fn root_import(ctx: &BindgenContext, module: &Item) -> quote::Tokens { + + + let mut tokens = quote! {}; +- tokens.append_separated(path, Term::new("::", Span::call_site())); ++ tokens.append_separated(path, quote!(::)); + + quote! { + #[allow(unused_imports)] +@@ -85,7 +86,7 @@ fn root_import(ctx: &BindgenContext, module: &Item) -> quote::Tokens { + } + + struct CodegenResult<'a> { +- items: Vec, ++ items: Vec, + + /// A monotonic counter used to add stable unique id's to stuff that doesn't + /// need to be referenced by anything. +@@ -212,7 +213,7 @@ impl<'a> CodegenResult<'a> { + self.vars_seen.insert(name.into()); + } + +- fn inner(&mut self, cb: F) -> Vec ++ fn inner(&mut self, cb: F) -> Vec + where + F: FnOnce(&mut Self), + { +@@ -231,7 +232,7 @@ impl<'a> CodegenResult<'a> { + } + + impl<'a> ops::Deref for CodegenResult<'a> { +- type Target = Vec; ++ type Target = Vec; + + fn deref(&self) -> &Self::Target { + &self.items +@@ -247,11 +248,11 @@ impl<'a> ops::DerefMut for CodegenResult<'a> { + /// A trait to convert a rust type into a pointer, optionally const, to the same + /// type. + trait ToPtr { +- fn to_ptr(self, is_const: bool) -> quote::Tokens; ++ fn to_ptr(self, is_const: bool) -> proc_macro2::TokenStream; + } + +-impl ToPtr for quote::Tokens { +- fn to_ptr(self, is_const: bool) -> quote::Tokens { ++impl ToPtr for proc_macro2::TokenStream { ++ fn to_ptr(self, is_const: bool) -> proc_macro2::TokenStream { + if is_const { + quote! { *const #self } + } else { +@@ -260,7 +261,7 @@ impl ToPtr for quote::Tokens { + } + } + +-/// An extension trait for `quote::Tokens` that lets us append any implicit ++/// An extension trait for `proc_macro2::TokenStream` that lets us append any implicit + /// template parameters that exist for some type, if necessary. + trait AppendImplicitTemplateParams { + fn append_implicit_template_params( +@@ -270,7 +271,7 @@ trait AppendImplicitTemplateParams { + ); + } + +-impl AppendImplicitTemplateParams for quote::Tokens { ++impl AppendImplicitTemplateParams for proc_macro2::TokenStream { + fn append_implicit_template_params( + &mut self, + ctx: &BindgenContext, +@@ -439,10 +440,7 @@ impl CodeGenerator for Module { + if let Some(raw_lines) = ctx.options().module_lines.get(&path) { + for raw_line in raw_lines { + found_any = true; +- // FIXME(emilio): The use of `Term` is an abuse, but we abuse it +- // in a bunch more places. +- let line = Term::new(raw_line, Span::call_site()); +- result.push(quote! { #line }); ++ result.push(proc_macro2::TokenStream::from_str(raw_line).unwrap()); + } + } + +@@ -745,7 +743,7 @@ impl CodeGenerator for Type { + pub use + }); + let path = top_level_path(ctx, item); +- tokens.append_separated(path, Term::new("::", Span::call_site())); ++ tokens.append_separated(path, quote!(::)); + tokens.append_all(quote! { + :: #inner_rust_type as #rust_name ; + }); +@@ -857,7 +855,7 @@ impl<'a> TryToRustTy for Vtable<'a> { + &self, + ctx: &BindgenContext, + _: &(), +- ) -> error::Result { ++ ) -> error::Result { + let name = ctx.rust_ident(self.canonical_name(ctx)); + Ok(quote! { + #name +@@ -952,8 +950,8 @@ trait FieldCodegen<'a> { + methods: &mut M, + extra: Self::Extra, + ) where +- F: Extend, +- M: Extend; ++ F: Extend, ++ M: Extend; + } + + impl<'a> FieldCodegen<'a> for Field { +@@ -972,8 +970,8 @@ impl<'a> FieldCodegen<'a> for Field { + methods: &mut M, + _: (), + ) where +- F: Extend, +- M: Extend, ++ F: Extend, ++ M: Extend, + { + match *self { + Field::DataMember(ref data) => { +@@ -1024,8 +1022,8 @@ impl<'a> FieldCodegen<'a> for FieldData { + methods: &mut M, + _: (), + ) where +- F: Extend, +- M: Extend, ++ F: Extend, ++ M: Extend, + { + // Bitfields are handled by `FieldCodegen` implementations for + // `BitfieldUnit` and `Bitfield`. +@@ -1159,8 +1157,8 @@ impl<'a> FieldCodegen<'a> for FieldData { + + impl BitfieldUnit { + /// Get the constructor name for this bitfield unit. +- fn ctor_name(&self) -> quote::Tokens { +- let ctor_name = Term::new(&format!("new_bitfield_{}", self.nth()), Span::call_site()); ++ fn ctor_name(&self) -> proc_macro2::TokenStream { ++ let ctor_name = Ident::new(&format!("new_bitfield_{}", self.nth()), Span::call_site()); + quote! { + #ctor_name + } +@@ -1178,9 +1176,9 @@ impl Bitfield { + fn extend_ctor_impl( + &self, + ctx: &BindgenContext, +- param_name: quote::Tokens, +- mut ctor_impl: quote::Tokens, +- ) -> quote::Tokens { ++ param_name: proc_macro2::TokenStream, ++ mut ctor_impl: proc_macro2::TokenStream, ++ ) -> proc_macro2::TokenStream { + let bitfield_ty = ctx.resolve_type(self.ty()); + let bitfield_ty_layout = bitfield_ty.layout(ctx).expect( + "Bitfield without layout? Gah!", +@@ -1224,8 +1222,8 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit { + methods: &mut M, + _: (), + ) where +- F: Extend, +- M: Extend, ++ F: Extend, ++ M: Extend, + { + result.saw_bitfield_unit(); + +@@ -1322,7 +1320,7 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit { + fn bitfield_getter_name( + ctx: &BindgenContext, + bitfield: &Bitfield, +-) -> quote::Tokens { ++) -> proc_macro2::TokenStream { + let name = bitfield.getter_name(); + let name = ctx.rust_ident_raw(name); + quote! { #name } +@@ -1331,7 +1329,7 @@ fn bitfield_getter_name( + fn bitfield_setter_name( + ctx: &BindgenContext, + bitfield: &Bitfield, +-) -> quote::Tokens { ++) -> proc_macro2::TokenStream { + let setter = bitfield.setter_name(); + let setter = ctx.rust_ident_raw(setter); + quote! { #setter } +@@ -1353,13 +1351,13 @@ impl<'a> FieldCodegen<'a> for Bitfield { + methods: &mut M, + (unit_field_name, bitfield_representable_as_int): (&'a str, &mut bool), + ) where +- F: Extend, +- M: Extend, ++ F: Extend, ++ M: Extend, + { + let prefix = ctx.trait_prefix(); + let getter_name = bitfield_getter_name(ctx, self); + let setter_name = bitfield_setter_name(ctx, self); +- let unit_field_ident = Term::new(unit_field_name, Span::call_site()); ++ let unit_field_ident = Ident::new(unit_field_name, Span::call_site()); + + let bitfield_ty_item = ctx.resolve_item(self.ty()); + let bitfield_ty = bitfield_ty_item.expect_type(); +@@ -1792,7 +1790,7 @@ impl CodeGenerator for CompInfo { + if self.found_unknown_attr() { + warn!( + "Type {} has an unknown attribute that may affect layout", +- canonical_ident.as_str() ++ canonical_ident + ); + } + +@@ -1806,7 +1804,7 @@ impl CodeGenerator for CompInfo { + if ctx.options().layout_tests && !self.is_forward_declaration() { + if let Some(layout) = layout { + let fn_name = +- format!("bindgen_test_layout_{}", canonical_ident.as_str()); ++ format!("bindgen_test_layout_{}", canonical_ident); + let fn_name = ctx.rust_ident_raw(fn_name); + let prefix = ctx.trait_prefix(); + let size_of_expr = quote! { +@@ -1868,7 +1866,7 @@ impl CodeGenerator for CompInfo { + }) + }) + }) +- .collect::>(); ++ .collect::>(); + + asserts + }; +@@ -2008,7 +2006,7 @@ trait MethodCodegen { + fn codegen_method<'a>( + &self, + ctx: &BindgenContext, +- methods: &mut Vec, ++ methods: &mut Vec, + method_names: &mut HashMap, + result: &mut CodegenResult<'a>, + parent: &CompInfo, +@@ -2019,7 +2017,7 @@ impl MethodCodegen for Method { + fn codegen_method<'a>( + &self, + ctx: &BindgenContext, +- methods: &mut Vec, ++ methods: &mut Vec, + method_names: &mut HashMap, + result: &mut CodegenResult<'a>, + _parent: &CompInfo, +@@ -2220,24 +2218,24 @@ impl std::str::FromStr for EnumVariation { + enum EnumBuilder<'a> { + Rust { + codegen_depth: usize, +- attrs: Vec, +- ident: Term, +- tokens: quote::Tokens, ++ attrs: Vec, ++ ident: Ident, ++ tokens: proc_macro2::TokenStream, + emitted_any_variants: bool, + }, + Bitfield { + codegen_depth: usize, + canonical_name: &'a str, +- tokens: quote::Tokens, ++ tokens: proc_macro2::TokenStream, + }, + Consts { +- variants: Vec, ++ variants: Vec, + codegen_depth: usize, + }, + ModuleConsts { + codegen_depth: usize, + module_name: &'a str, +- module_items: Vec, ++ module_items: Vec, + }, + } + +@@ -2256,12 +2254,12 @@ impl<'a> EnumBuilder<'a> { + /// the representation, and which variation it should be generated as. + fn new( + name: &'a str, +- attrs: Vec, +- repr: quote::Tokens, ++ attrs: Vec, ++ repr: proc_macro2::TokenStream, + enum_variation: EnumVariation, + enum_codegen_depth: usize, + ) -> Self { +- let ident = Term::new(name, Span::call_site()); ++ let ident = Ident::new(name, Span::call_site()); + + match enum_variation { + EnumVariation::Bitfield => { +@@ -2299,7 +2297,7 @@ impl<'a> EnumBuilder<'a> { + } + + EnumVariation::ModuleConsts => { +- let ident = Term::new(CONSTIFIED_ENUM_MODULE_REPR_NAME, Span::call_site()); ++ let ident = Ident::new(CONSTIFIED_ENUM_MODULE_REPR_NAME, Span::call_site()); + let type_definition = quote! { + #( #attrs )* + pub type #ident = #repr; +@@ -2320,7 +2318,7 @@ impl<'a> EnumBuilder<'a> { + ctx: &BindgenContext, + variant: &EnumVariant, + mangling_prefix: Option<&str>, +- rust_ty: quote::Tokens, ++ rust_ty: proc_macro2::TokenStream, + result: &mut CodegenResult<'b>, + is_ty_named: bool, + ) -> Self { +@@ -2422,9 +2420,9 @@ impl<'a> EnumBuilder<'a> { + fn build<'b>( + self, + ctx: &BindgenContext, +- rust_ty: quote::Tokens, ++ rust_ty: proc_macro2::TokenStream, + result: &mut CodegenResult<'b>, +- ) -> quote::Tokens { ++ ) -> proc_macro2::TokenStream { + match self { + EnumBuilder::Rust { attrs, ident, tokens, emitted_any_variants, .. } => { + let variants = if !emitted_any_variants { +@@ -2607,23 +2605,23 @@ impl CodeGenerator for Enum { + ctx: &BindgenContext, + enum_: &Type, + // Only to avoid recomputing every time. +- enum_canonical_name: &Term, ++ enum_canonical_name: &Ident, + // May be the same as "variant" if it's because the + // enum is unnamed and we still haven't seen the + // value. +- variant_name: &str, +- referenced_name: &Term, +- enum_rust_ty: quote::Tokens, ++ variant_name: &Ident, ++ referenced_name: &Ident, ++ enum_rust_ty: proc_macro2::TokenStream, + result: &mut CodegenResult<'a>, + ) { + let constant_name = if enum_.name().is_some() { + if ctx.options().prepend_enum_name { +- format!("{}_{}", enum_canonical_name.as_str(), variant_name) ++ format!("{}_{}", enum_canonical_name, variant_name) + } else { +- variant_name.into() ++ format!("{}", variant_name) + } + } else { +- variant_name.into() ++ format!("{}", variant_name) + }; + let constant_name = ctx.rust_ident(constant_name); + +@@ -2647,7 +2645,7 @@ impl CodeGenerator for Enum { + ); + + // A map where we keep a value -> variant relation. +- let mut seen_values = HashMap::<_, Term>::new(); ++ let mut seen_values = HashMap::<_, Ident>::new(); + let enum_rust_ty = item.to_rust_ty_or_opaque(ctx, &()); + let is_toplevel = item.is_toplevel(ctx); + +@@ -2719,7 +2717,7 @@ impl CodeGenerator for Enum { + ctx, + enum_ty, + &ident, +- &*mangled_name, ++ &Ident::new(&*mangled_name, Span::call_site()), + existing_variant_name, + enum_rust_ty.clone(), + result, +@@ -2760,11 +2758,11 @@ impl CodeGenerator for Enum { + let parent_name = + parent_canonical_name.as_ref().unwrap(); + +- Term::new( ++ Ident::new( + &format!( + "{}_{}", + parent_name, +- variant_name.as_str() ++ variant_name + ), + Span::call_site() + ) +@@ -2774,7 +2772,7 @@ impl CodeGenerator for Enum { + ctx, + enum_ty, + &ident, +- mangled_name.as_str(), ++ &mangled_name, + &variant_name, + enum_rust_ty.clone(), + result, +@@ -2811,7 +2809,7 @@ trait TryToOpaque { + &self, + ctx: &BindgenContext, + extra: &Self::Extra, +- ) -> error::Result { ++ ) -> error::Result { + self.try_get_layout(ctx, extra).map(|layout| { + helpers::blob(ctx, layout) + }) +@@ -2838,7 +2836,7 @@ trait ToOpaque: TryToOpaque { + &self, + ctx: &BindgenContext, + extra: &Self::Extra, +- ) -> quote::Tokens { ++ ) -> proc_macro2::TokenStream { + let layout = self.get_layout(ctx, extra); + helpers::blob(ctx, layout) + } +@@ -2864,7 +2862,7 @@ trait TryToRustTy { + &self, + ctx: &BindgenContext, + extra: &Self::Extra, +- ) -> error::Result; ++ ) -> error::Result; + } + + /// Fallible conversion to a Rust type or an opaque blob with the correct size +@@ -2879,7 +2877,7 @@ trait TryToRustTyOrOpaque: TryToRustTy + TryToOpaque { + &self, + ctx: &BindgenContext, + extra: &::Extra, +- ) -> error::Result; ++ ) -> error::Result; + } + + impl TryToRustTyOrOpaque for T +@@ -2893,7 +2891,7 @@ where + &self, + ctx: &BindgenContext, + extra: &E, +- ) -> error::Result { ++ ) -> error::Result { + self.try_to_rust_ty(ctx, extra).or_else( + |_| if let Ok(layout) = + self.try_get_layout(ctx, extra) +@@ -2930,7 +2928,7 @@ trait ToRustTyOrOpaque: TryToRustTy + ToOpaque { + &self, + ctx: &BindgenContext, + extra: &::Extra, +- ) -> quote::Tokens; ++ ) -> proc_macro2::TokenStream; + } + + impl ToRustTyOrOpaque for T +@@ -2943,7 +2941,7 @@ where + &self, + ctx: &BindgenContext, + extra: &E, +- ) -> quote::Tokens { ++ ) -> proc_macro2::TokenStream { + self.try_to_rust_ty(ctx, extra).unwrap_or_else(|_| { + self.to_opaque(ctx, extra) + }) +@@ -2975,7 +2973,7 @@ where + &self, + ctx: &BindgenContext, + _: &(), +- ) -> error::Result { ++ ) -> error::Result { + ctx.resolve_item((*self).into()).try_to_rust_ty(ctx, &()) + } + } +@@ -2999,7 +2997,7 @@ impl TryToRustTy for Item { + &self, + ctx: &BindgenContext, + _: &(), +- ) -> error::Result { ++ ) -> error::Result { + self.kind().expect_type().try_to_rust_ty(ctx, self) + } + } +@@ -3023,7 +3021,7 @@ impl TryToRustTy for Type { + &self, + ctx: &BindgenContext, + item: &Item, +- ) -> error::Result { ++ ) -> error::Result { + use self::helpers::ast_ty::*; + + match *self.kind() { +@@ -3125,7 +3123,7 @@ impl TryToRustTy for Type { + } + TypeKind::Enum(..) => { + let path = item.namespace_aware_canonical_path(ctx); +- let path = Term::new(&path.join("::"), Span::call_site()); ++ let path = proc_macro2::TokenStream::from_str(&path.join("::")).unwrap(); + Ok(quote!(#path)) + } + TypeKind::TemplateInstantiation(ref inst) => { +@@ -3224,7 +3222,7 @@ impl TryToRustTy for TemplateInstantiation { + &self, + ctx: &BindgenContext, + item: &Item, +- ) -> error::Result { ++ ) -> error::Result { + if self.is_opaque(ctx, item) { + return Err(error::Error::InstantiationOfOpaqueType); + } +@@ -3236,7 +3234,7 @@ impl TryToRustTy for TemplateInstantiation { + + let mut ty = quote! {}; + let def_path = def.namespace_aware_canonical_path(ctx); +- ty.append_separated(def_path.into_iter().map(|p| ctx.rust_ident(p)), Term::new("::", Span::call_site())); ++ ty.append_separated(def_path.into_iter().map(|p| ctx.rust_ident(p)), quote!(::)); + + let def_params = def.self_template_params(ctx); + if def_params.is_empty() { +@@ -3288,7 +3286,7 @@ impl TryToRustTy for FunctionSig { + &self, + ctx: &BindgenContext, + _: &(), +- ) -> error::Result { ++ ) -> error::Result { + // TODO: we might want to consider ignoring the reference return value. + let ret = utils::fnsig_return_ty(ctx, &self); + let arguments = utils::fnsig_arguments(ctx, &self); +@@ -3297,7 +3295,7 @@ impl TryToRustTy for FunctionSig { + match abi { + Abi::ThisCall if !ctx.options().rust_features().thiscall_abi => { + warn!("Skipping function with thiscall ABI that isn't supported by the configured Rust target"); +- Ok(quote::Tokens::new()) ++ Ok(proc_macro2::TokenStream::new()) + } + _ => { + Ok(quote! { +@@ -3423,7 +3421,7 @@ fn objc_method_codegen( + method: &ObjCMethod, + class_name: Option<&str>, + prefix: &str, +-) -> (quote::Tokens, quote::Tokens) { ++) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) { + let signature = method.signature(); + let fn_args = utils::fnsig_arguments(ctx, signature); + let fn_ret = utils::fnsig_return_ty(ctx, signature); +@@ -3537,7 +3535,7 @@ impl CodeGenerator for ObjCInterface { + } + } + +-pub(crate) fn codegen(context: BindgenContext) -> (Vec, BindgenOptions) { ++pub(crate) fn codegen(context: BindgenContext) -> (Vec, BindgenOptions) { + context.gen(|context| { + let _t = context.timer("codegen"); + let counter = Cell::new(0); +@@ -3573,12 +3571,12 @@ mod utils { + use ir::function::FunctionSig; + use ir::item::{Item, ItemCanonicalPath}; + use ir::ty::TypeKind; +- use quote; +- use proc_macro2::{Term, Span}; ++ use proc_macro2; + use std::mem; ++ use std::str::FromStr; + +- pub fn prepend_bitfield_unit_type(result: &mut Vec) { +- let bitfield_unit_type = Term::new(include_str!("./bitfield_unit.rs"), Span::call_site()); ++ pub fn prepend_bitfield_unit_type(result: &mut Vec) { ++ let bitfield_unit_type = proc_macro2::TokenStream::from_str(include_str!("./bitfield_unit.rs")).unwrap(); + let bitfield_unit_type = quote!(#bitfield_unit_type); + + let items = vec![bitfield_unit_type]; +@@ -3588,7 +3586,7 @@ mod utils { + + pub fn prepend_objc_header( + ctx: &BindgenContext, +- result: &mut Vec, ++ result: &mut Vec, + ) { + let use_objc = if ctx.options().objc_extern_crate { + quote! { +@@ -3613,7 +3611,7 @@ mod utils { + + pub fn prepend_block_header( + ctx: &BindgenContext, +- result: &mut Vec, ++ result: &mut Vec, + ) { + let use_block = if ctx.options().block_extern_crate { + quote! { +@@ -3632,7 +3630,7 @@ mod utils { + + pub fn prepend_union_types( + ctx: &BindgenContext, +- result: &mut Vec, ++ result: &mut Vec, + ) { + let prefix = ctx.trait_prefix(); + +@@ -3731,7 +3729,7 @@ mod utils { + + pub fn prepend_incomplete_array_types( + ctx: &BindgenContext, +- result: &mut Vec, ++ result: &mut Vec, + ) { + let prefix = ctx.trait_prefix(); + +@@ -3804,7 +3802,7 @@ mod utils { + } + + pub fn prepend_complex_type( +- result: &mut Vec, ++ result: &mut Vec, + ) { + let complex_type = quote! { + #[derive(PartialEq, Copy, Clone, Hash, Debug, Default)] +@@ -3823,18 +3821,14 @@ mod utils { + pub fn build_path( + item: &Item, + ctx: &BindgenContext, +- ) -> error::Result { +- use proc_macro2::{Term, Span}; +- ++ ) -> error::Result { + let path = item.namespace_aware_canonical_path(ctx); +- let path = Term::new(&path.join("::"), Span::call_site()); +- let tokens = quote! {#path}; +- //tokens.append_separated(path, "::"); ++ let tokens = proc_macro2::TokenStream::from_str(&path.join("::")).unwrap(); + + Ok(tokens) + } + +- fn primitive_ty(ctx: &BindgenContext, name: &str) -> quote::Tokens { ++ fn primitive_ty(ctx: &BindgenContext, name: &str) -> proc_macro2::TokenStream { + let ident = ctx.rust_ident_raw(name); + quote! { + #ident +@@ -3844,7 +3838,7 @@ mod utils { + pub fn type_from_named( + ctx: &BindgenContext, + name: &str, +- ) -> Option { ++ ) -> Option { + // FIXME: We could use the inner item to check this is really a + // primitive type but, who the heck overrides these anyway? + Some(match name { +@@ -3867,7 +3861,7 @@ mod utils { + pub fn fnsig_return_ty( + ctx: &BindgenContext, + sig: &FunctionSig, +- ) -> quote::Tokens { ++ ) -> proc_macro2::TokenStream { + let return_item = ctx.resolve_item(sig.return_type()); + if let TypeKind::Void = *return_item.kind().expect_type().kind() { + quote! { } +@@ -3882,7 +3876,7 @@ mod utils { + pub fn fnsig_arguments( + ctx: &BindgenContext, + sig: &FunctionSig, +- ) -> Vec { ++ ) -> Vec { + use super::ToPtr; + + let mut unnamed_arguments = 0; +@@ -3945,7 +3939,7 @@ mod utils { + pub fn fnsig_block( + ctx: &BindgenContext, + sig: &FunctionSig, +- ) -> quote::Tokens { ++ ) -> proc_macro2::TokenStream { + let args = sig.argument_types().iter().map(|&(_, ty)| { + let arg_item = ctx.resolve_item(ty); + +diff --git a/src/codegen/struct_layout.rs b/src/codegen/struct_layout.rs +index 0ea23ddf..921ab215 100644 +--- a/src/codegen/struct_layout.rs ++++ b/src/codegen/struct_layout.rs +@@ -6,8 +6,7 @@ use ir::comp::CompInfo; + use ir::context::BindgenContext; + use ir::layout::Layout; + use ir::ty::{Type, TypeKind}; +-use quote; +-use proc_macro2::{Term, Span}; ++use proc_macro2::{self, Ident, Span}; + use std::cmp; + + /// Trace the layout of struct. +@@ -154,7 +153,7 @@ impl<'a> StructLayoutTracker<'a> { + field_name: &str, + field_ty: &Type, + field_offset: Option, +- ) -> Option { ++ ) -> Option { + let mut field_layout = field_ty.layout(self.ctx)?; + + if let TypeKind::Array(inner, len) = +@@ -236,7 +235,7 @@ impl<'a> StructLayoutTracker<'a> { + padding_layout.map(|layout| self.padding_field(layout)) + } + +- pub fn pad_struct(&mut self, layout: Layout) -> Option { ++ pub fn pad_struct(&mut self, layout: Layout) -> Option { + debug!( + "pad_struct:\n\tself = {:#?}\n\tlayout = {:#?}", + self, +@@ -310,13 +309,13 @@ impl<'a> StructLayoutTracker<'a> { + align_to(self.latest_offset, layout.align) - self.latest_offset + } + +- fn padding_field(&mut self, layout: Layout) -> quote::Tokens { ++ fn padding_field(&mut self, layout: Layout) -> proc_macro2::TokenStream { + let ty = helpers::blob(self.ctx, layout); + let padding_count = self.padding_count; + + self.padding_count += 1; + +- let padding_field_name = Term::new(&format!("__bindgen_padding_{}", padding_count), Span::call_site()); ++ let padding_field_name = Ident::new(&format!("__bindgen_padding_{}", padding_count), Span::call_site()); + + self.max_field_align = cmp::max(self.max_field_align, layout.align); + +diff --git a/src/ir/context.rs b/src/ir/context.rs +index bdf38428..7dcecebe 100644 +--- a/src/ir/context.rs ++++ b/src/ir/context.rs +@@ -24,7 +24,7 @@ use cexpr; + use clang::{self, Cursor}; + use clang_sys; + use parse::ClangItemParser; +-use proc_macro2::{Term, Span}; ++use proc_macro2::{Ident, Span}; + use std::borrow::Cow; + use std::cell::Cell; + use std::collections::{HashMap, HashSet, hash_map}; +@@ -922,7 +922,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" + } + + /// Returns a mangled name as a rust identifier. +- pub fn rust_ident(&self, name: S) -> Term ++ pub fn rust_ident(&self, name: S) -> Ident + where + S: AsRef + { +@@ -930,11 +930,11 @@ If you encounter an error missing from this list, please file an issue or a PR!" + } + + /// Returns a mangled name as a rust identifier. +- pub fn rust_ident_raw(&self, name: T) -> Term ++ pub fn rust_ident_raw(&self, name: T) -> Ident + where + T: AsRef + { +- Term::new(name.as_ref(), Span::call_site()) ++ Ident::new(name.as_ref(), Span::call_site()) + } + + /// Iterate over all items that have been defined. +@@ -2386,7 +2386,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" + + /// Convenient method for getting the prefix to use for most traits in + /// codegen depending on the `use_core` option. +- pub fn trait_prefix(&self) -> Term { ++ pub fn trait_prefix(&self) -> Ident { + if self.options().use_core { + self.rust_ident_raw("core") + } else { +diff --git a/src/ir/function.rs b/src/ir/function.rs +index 3f2c8254..d0cc021c 100644 +--- a/src/ir/function.rs ++++ b/src/ir/function.rs +@@ -12,6 +12,8 @@ use ir::derive::{CanTriviallyDeriveDebug, CanTriviallyDeriveHash, + CanTriviallyDerivePartialEqOrPartialOrd, CanDerive}; + use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult}; + use quote; ++use quote::TokenStreamExt; ++use proc_macro2; + use std::io; + + const RUST_DERIVE_FUNPTR_LIMIT: usize = 12; +@@ -192,7 +194,7 @@ impl Abi { + } + + impl quote::ToTokens for Abi { +- fn to_tokens(&self, tokens: &mut quote::Tokens) { ++ fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { + tokens.append_all(match *self { + Abi::C => quote! { "C" }, + Abi::Stdcall => quote! { "stdcall" }, +diff --git a/src/ir/objc.rs b/src/ir/objc.rs +index 46c0802e..61c22356 100644 +--- a/src/ir/objc.rs ++++ b/src/ir/objc.rs +@@ -12,8 +12,7 @@ use clang_sys::CXCursor_ObjCClassRef; + use clang_sys::CXCursor_ObjCInstanceMethodDecl; + use clang_sys::CXCursor_ObjCProtocolDecl; + use clang_sys::CXCursor_ObjCProtocolRef; +-use quote; +-use proc_macro2::{Term, Span}; ++use proc_macro2::{TokenStream, Ident, Span}; + + /// Objective C interface as used in TypeKind + /// +@@ -213,11 +212,11 @@ impl ObjCMethod { + } + + /// Formats the method call +- pub fn format_method_call(&self, args: &[quote::Tokens]) -> quote::Tokens { ++ pub fn format_method_call(&self, args: &[TokenStream]) -> TokenStream { + let split_name: Vec<_> = self.name + .split(':') + .filter(|p| !p.is_empty()) +- .map(|name| Term::new(name, Span::call_site())) ++ .map(|name| Ident::new(name, Span::call_site())) + .collect(); + + // No arguments +@@ -243,7 +242,7 @@ impl ObjCMethod { + let arg = arg.to_string(); + let name_and_sig: Vec<&str> = arg.split(' ').collect(); + let name = name_and_sig[0]; +- args_without_types.push(Term::new(name, Span::call_site())) ++ args_without_types.push(Ident::new(name, Span::call_site())) + }; + + let args = split_name +diff --git a/src/lib.rs b/src/lib.rs +index a89102d8..a5818eb5 100644 +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -1632,7 +1632,7 @@ fn ensure_libclang_is_loaded() { + #[derive(Debug)] + pub struct Bindings { + options: BindgenOptions, +- module: quote::Tokens, ++ module: proc_macro2::TokenStream, + } + + impl Bindings { +-- +2.19.0 + diff --git a/bindgen-fix-metadata.diff b/bindgen-fix-metadata.diff new file mode 100644 index 0000000..92d087a --- /dev/null +++ b/bindgen-fix-metadata.diff @@ -0,0 +1,16 @@ +--- bindgen-0.42.0/Cargo.toml 1970-01-01T01:00:00+01:00 ++++ bindgen-0.42.0/Cargo.toml 2018-10-04T17:12:48.839921+02:00 +@@ -63,11 +63,11 @@ + version = "0.1.2" + + [dependencies.proc-macro2] +-version = "0.3.2, < 0.3.6" ++version = "0.4" + default-features = false + + [dependencies.quote] +-version = "0.5" ++version = "0.6" + default-features = false + + [dependencies.regex] diff --git a/rust-bindgen.spec b/rust-bindgen.spec new file mode 100644 index 0000000..934f5b0 --- /dev/null +++ b/rust-bindgen.spec @@ -0,0 +1,91 @@ +# Generated by rust2rpm +%bcond_without check + +%global crate bindgen + +Name: rust-%{crate} +Version: 0.42.0 +Release: 1%{?dist} +Summary: Automatically generates Rust FFI bindings to C and C++ libraries + +# Upstream license specification: BSD-3-Clause +License: BSD +URL: https://crates.io/crates/bindgen +Source0: https://crates.io/api/v1/crates/%{crate}/%{version}/download#/%{crate}-%{version}.crate +# Initial patched metadata +# * Update quote and proc-macro2 +Patch0: bindgen-fix-metadata.diff +# https://github.com/rust-lang-nursery/rust-bindgen/pull/1409 +Patch0001: 0001-Update-quote-and-proc-macro.patch + +ExclusiveArch: %{rust_arches} + +BuildRequires: rust-packaging +# [dependencies] +BuildRequires: (crate(bitflags) >= 1.0.3 with crate(bitflags) < 2.0.0) +BuildRequires: (crate(cexpr) >= 0.3.0 with crate(cexpr) < 0.4.0) +BuildRequires: (crate(cfg-if) >= 0.1.0 with crate(cfg-if) < 0.2.0) +BuildRequires: ((crate(clang-sys) >= 0.24.0 with crate(clang-sys) < 0.25.0) with crate(clang-sys/runtime) with crate(clang-sys/clang_6_0)) +BuildRequires: (crate(clap) >= 2.0.0 with crate(clap) < 3.0.0) +BuildRequires: (crate(env_logger) >= 0.5.0 with crate(env_logger) < 0.6.0) +BuildRequires: (crate(lazy_static) >= 1.0.0 with crate(lazy_static) < 2.0.0) +BuildRequires: (crate(log) >= 0.4.0 with crate(log) < 0.5.0) +BuildRequires: (crate(peeking_take_while) >= 0.1.2 with crate(peeking_take_while) < 0.2.0) +BuildRequires: (crate(proc-macro2) >= 0.4.0 with crate(proc-macro2) < 0.5.0) +BuildRequires: (crate(quote) >= 0.6.0 with crate(quote) < 0.7.0) +BuildRequires: (crate(regex) >= 1.0.0 with crate(regex) < 2.0.0) +BuildRequires: (crate(which) >= 1.0.2 with crate(which) < 2.0.0) +%if %{with check} +# [dev-dependencies] +BuildRequires: (crate(clap) >= 2.0.0 with crate(clap) < 3.0.0) +BuildRequires: (crate(diff) >= 0.1.0 with crate(diff) < 0.2.0) +BuildRequires: (crate(shlex) >= 0.1.0 with crate(shlex) < 0.2.0) +%endif + +%description +%{summary}. + +%package -n %{crate} +Summary: %{summary} + +%description -n %{crate} +%{summary}. + +%package devel +Summary: %{summary} +BuildArch: noarch + +%description devel +Automatically generates Rust FFI bindings to C and C++ libraries. + +This package contains library source intended for building other packages +which use %{crate} from crates.io. + +%prep +%autosetup -n %{crate}-%{version} -p1 +%cargo_prep + +%build +%cargo_build + +%install +%cargo_install + +%if %{with check} +%check +%cargo_test +%endif + +%files -n %{crate} +%license LICENSE +%doc README.md +%{_bindir}/bindgen + +%files devel +%license LICENSE +%doc README.md +%{cargo_registry}/%{crate}-%{version}/ + +%changelog +* Thu Oct 04 2018 Igor Gnatenko - 0.42.0-1 +- Initial package diff --git a/sources b/sources new file mode 100644 index 0000000..f884820 --- /dev/null +++ b/sources @@ -0,0 +1 @@ +SHA512 (bindgen-0.42.0.crate) = 532a4f2d5397f8f015e89e3bc00e7b8e44c614ae459fe7fbd9f37d95cceb6d31bb1b143dead16d235381c1a00968bf0b6e55d3e6bf47eba9f438a238ce371820