diff options
Diffstat (limited to 'src/codegen/mod.rs')
| -rw-r--r-- | src/codegen/mod.rs | 1656 |
1 files changed, 903 insertions, 753 deletions
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs index 5c00a53d..7324a0ed 100644 --- a/src/codegen/mod.rs +++ b/src/codegen/mod.rs @@ -1,17 +1,18 @@ +mod derive_debug; mod error; mod helpers; pub mod struct_layout; -use self::helpers::{BlobTyBuilder, attributes}; +use self::helpers::{attributes, BlobTyBuilder}; use self::struct_layout::StructLayoutTracker; use aster; use aster::struct_field::StructFieldBuilder; use ir::annotations::FieldAccessorKind; -use ir::comp::{Base, BitfieldUnit, Bitfield, CompInfo, CompKind, Field, - FieldData, FieldMethods, Method, MethodKind}; use ir::comment; +use ir::comp::{Base, Bitfield, BitfieldUnit, CompInfo, CompKind, Field, + FieldData, FieldMethods, Method, MethodKind}; use ir::context::{BindgenContext, ItemId}; use ir::derive::{CanDeriveCopy, CanDeriveDebug, CanDeriveDefault}; use ir::dot; @@ -36,7 +37,7 @@ use std::mem; use std::ops; use syntax::abi; use syntax::ast; -use syntax::codemap::{DUMMY_SP, Span, respan}; +use syntax::codemap::{respan, Span, DUMMY_SP}; use syntax::ptr::P; // Name of type defined in constified enum module @@ -181,7 +182,8 @@ impl<'a> CodegenResult<'a> { } fn inner<F>(&mut self, cb: F) -> Vec<P<ast::Item>> - where F: FnOnce(&mut Self), + where + F: FnOnce(&mut Self), { let mut new = Self::new(self.codegen_id); @@ -230,7 +232,8 @@ impl ForeignModBuilder { #[allow(dead_code)] fn with_foreign_items<I>(mut self, items: I) -> Self - where I: IntoIterator<Item = ast::ForeignItem>, + where + I: IntoIterator<Item = ast::ForeignItem>, { self.inner.items.extend(items.into_iter()); self @@ -279,27 +282,33 @@ trait CodeGenerator { /// Extra information from the caller. type Extra; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - extra: &Self::Extra); + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + extra: &Self::Extra, + ); } impl CodeGenerator for Item { type Extra = (); - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - _extra: &()) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + _extra: &(), + ) { if !self.is_enabled_for_codegen(ctx) { return; } if self.is_hidden(ctx) || result.seen(self.id()) { - debug!("<Item as CodeGenerator>::codegen: Ignoring hidden or seen: \ - self = {:?}", - self); + debug!( + "<Item as CodeGenerator>::codegen: Ignoring hidden or seen: \ + self = {:?}", + self + ); return; } @@ -333,10 +342,12 @@ impl CodeGenerator for Item { impl CodeGenerator for Module { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { debug!("<Module as CodeGenerator>::codegen: item = {:?}", item); let codegen_self = |result: &mut CodegenResult, @@ -344,8 +355,7 @@ impl CodeGenerator for Module { for child in self.children() { if ctx.codegen_items().contains(child) { *found_any = true; - ctx.resolve_item(*child) - .codegen(ctx, result, &()); + ctx.resolve_item(*child).codegen(ctx, result, &()); } } @@ -366,7 +376,9 @@ impl CodeGenerator for Module { }; if !ctx.options().enable_cxx_namespaces || - (self.is_inline() && !ctx.options().conservative_inline_namespaces) { + (self.is_inline() && + !ctx.options().conservative_inline_namespaces) + { codegen_self(result, &mut false); return; } @@ -388,14 +400,15 @@ impl CodeGenerator for Module { }); let name = item.canonical_name(ctx); - let item_builder = aster::AstBuilder::new() - .item() - .pub_(); + let item_builder = aster::AstBuilder::new().item().pub_(); let item = if name == "root" { - let attrs = &["non_snake_case", + let attrs = &[ + "non_snake_case", "non_camel_case_types", - "non_upper_case_globals"]; - item_builder.with_attr(attributes::allow(attrs)) + "non_upper_case_globals", + ]; + item_builder + .with_attr(attributes::allow(attrs)) .build_item_kind(name, module) } else { item_builder.build_item_kind(name, module) @@ -407,10 +420,12 @@ impl CodeGenerator for Module { impl CodeGenerator for Var { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { use ir::var::VarType; debug!("<Var as CodeGenerator>::codegen: item = {:?}", item); debug_assert!(item.is_enabled_for_codegen(ctx)); @@ -456,30 +471,23 @@ impl CodeGenerator for Var { let ty = quote_ty!(ctx.ext_cx(), [u8; $len]); match String::from_utf8(bytes.clone()) { - Ok(string) => { - const_item.build(helpers::ast_ty::cstr_expr(string)) - .build(quote_ty!(ctx.ext_cx(), &'static $ty)) - } - Err(..) => { - const_item - .build(helpers::ast_ty::byte_array_expr(bytes)) - .build(ty) - } + Ok(string) => const_item + .build(helpers::ast_ty::cstr_expr(string)) + .build(quote_ty!(ctx.ext_cx(), &'static $ty)), + Err(..) => const_item + .build(helpers::ast_ty::byte_array_expr(bytes)) + .build(ty), } } VarType::Float(f) => { match helpers::ast_ty::float_expr(ctx, f) { - Ok(expr) => { - const_item.build(expr).build(ty) - } + Ok(expr) => const_item.build(expr).build(ty), Err(..) => return, } } - VarType::Char(c) => { - const_item - .build(aster::AstBuilder::new().expr().lit().byte(c)) - .build(ty) - } + VarType::Char(c) => const_item + .build(aster::AstBuilder::new().expr().lit().byte(c)) + .build(ty), }; result.push(item); @@ -511,10 +519,12 @@ impl CodeGenerator for Var { impl CodeGenerator for Type { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { debug!("<Type as CodeGenerator>::codegen: item = {:?}", item); debug_assert!(item.is_enabled_for_codegen(ctx)); @@ -539,11 +549,8 @@ impl CodeGenerator for Type { TypeKind::TemplateInstantiation(ref inst) => { inst.codegen(ctx, result, item) } - TypeKind::Comp(ref ci) => { - ci.codegen(ctx, result, item) - } - TypeKind::TemplateAlias(inner, _) | - TypeKind::Alias(inner) => { + TypeKind::Comp(ref ci) => ci.codegen(ctx, result, item), + TypeKind::TemplateAlias(inner, _) | TypeKind::Alias(inner) => { let inner_item = ctx.resolve_item(inner); let name = item.canonical_name(ctx); @@ -572,7 +579,8 @@ impl CodeGenerator for Type { // Its possible that we have better layout information than // the inner type does, so fall back to an opaque blob based // on our layout if converting the inner item fails. - inner_item.try_to_rust_ty_or_opaque(ctx, &()) + inner_item + .try_to_rust_ty_or_opaque(ctx, &()) .unwrap_or_else(|_| self.to_opaque(ctx, item)) }; @@ -587,13 +595,15 @@ impl CodeGenerator for Type { // with invalid template parameters, and at least this way // they can be replaced, instead of generating plain invalid // code. - let inner_canon_type = inner_item.expect_type() - .canonical_type(ctx); + let inner_canon_type = + inner_item.expect_type().canonical_type(ctx); if inner_canon_type.is_invalid_named_type() { - warn!("Item contained invalid named type, skipping: \ - {:?}, {:?}", - item, - inner_item); + warn!( + "Item contained invalid named type, skipping: \ + {:?}, {:?}", + item, + inner_item + ); return; } } @@ -608,27 +618,30 @@ impl CodeGenerator for Type { // We prefer using `pub use` over `pub type` because of: // https://github.com/rust-lang/rust/issues/26264 let simple_enum_path = match inner_rust_type.node { - ast::TyKind::Path(None, ref p) => { - if used_template_params.is_none() && - inner_item.expect_type() + ast::TyKind::Path(None, ref p) => if used_template_params + .is_none() && + inner_item + .expect_type() .canonical_type(ctx) .is_enum() && - p.segments.iter().all(|p| p.parameters.is_none()) { - Some(p.clone()) - } else { - None - } - } + p.segments.iter().all(|p| p.parameters.is_none()) + { + Some(p.clone()) + } else { + None + }, _ => None, }; let typedef = if let Some(mut p) = simple_enum_path { for ident in top_level_path(ctx, item).into_iter().rev() { - p.segments.insert(0, - ast::PathSegment { - identifier: ident, - parameters: None, - }); + p.segments.insert( + 0, + ast::PathSegment { + identifier: ident, + parameters: None, + }, + ); } typedef.use_().build(p).as_(rust_name) } else { @@ -636,17 +649,21 @@ impl CodeGenerator for Type { if let Some(ref params) = used_template_params { for template_param in params { if let Some(id) = - template_param.as_template_param(ctx, &()) { + template_param.as_template_param(ctx, &()) + { let template_param = ctx.resolve_type(id); if template_param.is_invalid_named_type() { - warn!("Item contained invalid template \ - parameter: {:?}", - item); + warn!( + "Item contained invalid template \ + parameter: {:?}", + item + ); return; } generics = - generics.ty_param_id(template_param.name() - .unwrap()); + generics.ty_param_id( + template_param.name().unwrap(), + ); } } } @@ -654,9 +671,7 @@ impl CodeGenerator for Type { }; result.push(typedef) } - TypeKind::Enum(ref ei) => { - ei.codegen(ctx, result, item) - } + TypeKind::Enum(ref ei) => ei.codegen(ctx, result, item), TypeKind::ObjCId | TypeKind::ObjCSel => { result.saw_objc(); } @@ -679,10 +694,11 @@ struct Vtable<'a> { } impl<'a> Vtable<'a> { - fn new(item_id: ItemId, - methods: &'a [Method], - base_classes: &'a [Base]) - -> Self { + fn new( + item_id: ItemId, + methods: &'a [Method], + base_classes: &'a [Base], + ) -> Self { Vtable { item_id: item_id, methods: methods, @@ -694,10 +710,12 @@ impl<'a> Vtable<'a> { impl<'a> CodeGenerator for Vtable<'a> { type Extra = Item; - fn codegen<'b>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'b>, - item: &Item) { + fn codegen<'b>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'b>, + item: &Item, + ) { assert_eq!(item.id(), self.item_id); debug_assert!(item.is_enabled_for_codegen(ctx)); @@ -726,9 +744,11 @@ impl<'a> ItemCanonicalName for Vtable<'a> { impl<'a> TryToRustTy for Vtable<'a> { type Extra = (); - fn try_to_rust_ty(&self, - ctx: &BindgenContext, - _: &()) -> error::Result<P<ast::Ty>> { + fn try_to_rust_ty( + &self, + ctx: &BindgenContext, + _: &(), + ) -> error::Result<P<ast::Ty>> { Ok(aster::ty::TyBuilder::new().id(self.canonical_name(ctx))) } } @@ -736,10 +756,12 @@ impl<'a> TryToRustTy for Vtable<'a> { impl CodeGenerator for TemplateInstantiation { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { debug_assert!(item.is_enabled_for_codegen(ctx)); // Although uses of instantiations don't need code generation, and are @@ -749,7 +771,7 @@ impl CodeGenerator for TemplateInstantiation { // properly understand it (maybe because of specializations), and so we // shouldn't emit layout tests either. if !ctx.options().layout_tests || self.is_opaque(ctx, item) { - return + return; } // If there are any unbound type parameters, then we can't generate a @@ -766,7 +788,8 @@ impl CodeGenerator for TemplateInstantiation { let align = layout.align; let name = item.full_disambiguated_name(ctx); - let mut fn_name = format!("__bindgen_test_layout_{}_instantiation", name); + let mut fn_name = + format!("__bindgen_test_layout_{}_instantiation", name); let times_seen = result.overload_number(&fn_name); if times_seen > 0 { write!(&mut fn_name, "_{}", times_seen).unwrap(); @@ -791,8 +814,7 @@ impl CodeGenerator for TemplateInstantiation { assert_eq!($align_of_expr, $align, concat!("Alignment of template specialization: ", stringify!($ident))); - }) - .unwrap(); + }).unwrap(); result.push(item); } @@ -821,66 +843,74 @@ impl Iterator for AnonFieldNames { trait FieldCodegen<'a> { type Extra; - fn codegen<F, M>(&self, - ctx: &BindgenContext, - fields_should_be_private: bool, - codegen_depth: usize, - accessor_kind: FieldAccessorKind, - parent: &CompInfo, - anon_field_names: &mut AnonFieldNames, - result: &mut CodegenResult, - struct_layout: &mut StructLayoutTracker, - fields: &mut F, - methods: &mut M, - extra: Self::Extra) - where F: Extend<ast::StructField>, - M: Extend<ast::ImplItem>; + fn codegen<F, M>( + &self, + ctx: &BindgenContext, + fields_should_be_private: bool, + codegen_depth: usize, + accessor_kind: FieldAccessorKind, + parent: &CompInfo, + anon_field_names: &mut AnonFieldNames, + result: &mut CodegenResult, + struct_layout: &mut StructLayoutTracker, + fields: &mut F, + methods: &mut M, + extra: Self::Extra, + ) where + F: Extend<ast::StructField>, + M: Extend<ast::ImplItem>; } impl<'a> FieldCodegen<'a> for Field { type Extra = (); - fn codegen<F, M>(&self, - ctx: &BindgenContext, - fields_should_be_private: bool, - codegen_depth: usize, - accessor_kind: FieldAccessorKind, - parent: &CompInfo, - anon_field_names: &mut AnonFieldNames, - result: &mut CodegenResult, - struct_layout: &mut StructLayoutTracker, - fields: &mut F, - methods: &mut M, - _: ()) - where F: Extend<ast::StructField>, - M: Extend<ast::ImplItem> + fn codegen<F, M>( + &self, + ctx: &BindgenContext, + fields_should_be_private: bool, + codegen_depth: usize, + accessor_kind: FieldAccessorKind, + parent: &CompInfo, + anon_field_names: &mut AnonFieldNames, + result: &mut CodegenResult, + struct_layout: &mut StructLayoutTracker, + fields: &mut F, + methods: &mut M, + _: (), + ) where + F: Extend<ast::StructField>, + M: Extend<ast::ImplItem>, { match *self { Field::DataMember(ref data) => { - data.codegen(ctx, - fields_should_be_private, - codegen_depth, - accessor_kind, - parent, - anon_field_names, - result, - struct_layout, - fields, - methods, - ()); + data.codegen( + ctx, + fields_should_be_private, + codegen_depth, + accessor_kind, + parent, + anon_field_names, + result, + struct_layout, + fields, + methods, + (), + ); } Field::Bitfields(ref unit) => { - unit.codegen(ctx, - fields_should_be_private, - codegen_depth, - accessor_kind, - parent, - anon_field_names, - result, - struct_layout, - fields, - methods, - ()); + unit.codegen( + ctx, + fields_should_be_private, + codegen_depth, + accessor_kind, + parent, + anon_field_names, + result, + struct_layout, + fields, + methods, + (), + ); } } } @@ -889,20 +919,22 @@ impl<'a> FieldCodegen<'a> for Field { impl<'a> FieldCodegen<'a> for FieldData { type Extra = (); - fn codegen<F, M>(&self, - ctx: &BindgenContext, - fields_should_be_private: bool, - codegen_depth: usize, - accessor_kind: FieldAccessorKind, - parent: &CompInfo, - anon_field_names: &mut AnonFieldNames, - result: &mut CodegenResult, - struct_layout: &mut StructLayoutTracker, - fields: &mut F, - methods: &mut M, - _: ()) - where F: Extend<ast::StructField>, - M: Extend<ast::ImplItem> + fn codegen<F, M>( + &self, + ctx: &BindgenContext, + fields_should_be_private: bool, + codegen_depth: usize, + accessor_kind: FieldAccessorKind, + parent: &CompInfo, + anon_field_names: &mut AnonFieldNames, + result: &mut CodegenResult, + struct_layout: &mut StructLayoutTracker, + fields: &mut F, + methods: &mut M, + _: (), + ) where + F: Extend<ast::StructField>, + M: Extend<ast::ImplItem>, { // Bitfields are handled by `FieldCodegen` implementations for // `BitfieldUnit` and `Bitfield`. @@ -918,8 +950,7 @@ impl<'a> FieldCodegen<'a> for FieldData { } else { quote_ty!(ctx.ext_cx(), __BindgenUnionField<$ty>) } - } else if let Some(item) = - field_ty.is_incomplete_array(ctx) { + } else if let Some(item) = field_ty.is_incomplete_array(ctx) { result.saw_incomplete_array(); let inner = item.to_rust_ty_or_opaque(ctx, &()); @@ -936,7 +967,8 @@ impl<'a> FieldCodegen<'a> for FieldData { let mut attrs = vec![]; if ctx.options().generate_comments { if let Some(raw_comment) = self.comment() { - let comment = comment::preprocess(raw_comment, codegen_depth + 1); + let comment = + comment::preprocess(raw_comment, codegen_depth + 1); attrs.push(attributes::doc(comment)) } } @@ -947,7 +979,8 @@ impl<'a> FieldCodegen<'a> for FieldData { if !parent.is_union() { if let Some(padding_field) = - struct_layout.pad_field(&field_name, field_ty, self.offset()) { + struct_layout.pad_field(&field_name, field_ty, self.offset()) + { fields.extend(Some(padding_field)); } } @@ -956,9 +989,8 @@ impl<'a> FieldCodegen<'a> for FieldData { .private_fields() .unwrap_or(fields_should_be_private); - let accessor_kind = self.annotations() - .accessor_kind() - .unwrap_or(accessor_kind); + let accessor_kind = + self.annotations().accessor_kind().unwrap_or(accessor_kind); let mut field = StructFieldBuilder::named(&field_name); @@ -966,8 +998,7 @@ impl<'a> FieldCodegen<'a> for FieldData { field = field.pub_(); } - let field = field.with_attrs(attrs) - .build_ty(ty.clone()); + let field = field.with_attrs(attrs).build_ty(ty.clone()); fields.extend(Some(field)); @@ -976,16 +1007,14 @@ impl<'a> FieldCodegen<'a> for FieldData { return; } - let getter_name = - ctx.rust_ident_raw(&format!("get_{}", field_name)); + let getter_name = ctx.rust_ident_raw(&format!("get_{}", field_name)); let mutable_getter_name = ctx.rust_ident_raw(&format!("get_{}_mut", field_name)); let field_name = ctx.rust_ident_raw(&field_name); let accessor_methods_impl = match accessor_kind { FieldAccessorKind::None => unreachable!(), - FieldAccessorKind::Regular => { - quote_item!(ctx.ext_cx(), + FieldAccessorKind::Regular => quote_item!(ctx.ext_cx(), impl X { #[inline] pub fn $getter_name(&self) -> &$ty { @@ -997,10 +1026,8 @@ impl<'a> FieldCodegen<'a> for FieldData { &mut self.$field_name } } - ) - } - FieldAccessorKind::Unsafe => { - quote_item!(ctx.ext_cx(), + ), + FieldAccessorKind::Unsafe => quote_item!(ctx.ext_cx(), impl X { #[inline] pub unsafe fn $getter_name(&self) -> &$ty { @@ -1013,18 +1040,15 @@ impl<'a> FieldCodegen<'a> for FieldData { &mut self.$field_name } } - ) - } - FieldAccessorKind::Immutable => { - quote_item!(ctx.ext_cx(), + ), + FieldAccessorKind::Immutable => quote_item!(ctx.ext_cx(), impl X { #[inline] pub fn $getter_name(&self) -> &$ty { &self.$field_name } } - ) - } + ), }; match accessor_methods_impl.unwrap().node { @@ -1046,10 +1070,11 @@ impl BitfieldUnit { /// Get the initial bitfield unit constructor that just returns 0. This will /// then be extended by each bitfield in the unit. See `extend_ctor_impl` /// below. - fn initial_ctor_impl(&self, - ctx: &BindgenContext, - unit_field_int_ty: &P<ast::Ty>) - -> P<ast::Item> { + fn initial_ctor_impl( + &self, + ctx: &BindgenContext, + unit_field_int_ty: &P<ast::Ty>, + ) -> P<ast::Item> { let ctor_name = self.ctor_name(ctx); // If we're generating unstable Rust, add the const. @@ -1079,25 +1104,22 @@ impl Bitfield { /// /// 2. Bitwise or'ing the parameter into the final value of the constructed /// bitfield unit. - fn extend_ctor_impl(&self, - ctx: &BindgenContext, - parent: &CompInfo, - ctor_impl: P<ast::Item>, - ctor_name: &ast::Ident, - unit_field_int_ty: &P<ast::Ty>) - -> P<ast::Item> { + fn extend_ctor_impl( + &self, + ctx: &BindgenContext, + parent: &CompInfo, + ctor_impl: P<ast::Item>, + ctor_name: &ast::Ident, + unit_field_int_ty: &P<ast::Ty>, + ) -> P<ast::Item> { let items = match ctor_impl.unwrap().node { - ast::ItemKind::Impl(_, _, _, _, _, items) => { - items - } + ast::ItemKind::Impl(_, _, _, _, _, items) => items, _ => unreachable!(), }; assert_eq!(items.len(), 1); let (sig, body) = match items[0].node { - ast::ImplItemKind::Method(ref sig, ref body) => { - (sig, body) - } + ast::ImplItemKind::Method(ref sig, ref body) => (sig, body), _ => unreachable!(), }; @@ -1106,11 +1128,12 @@ impl Bitfield { let bitfield_ty_item = ctx.resolve_item(self.ty()); let bitfield_ty = bitfield_ty_item.expect_type(); - let bitfield_ty_layout = bitfield_ty.layout(ctx) + let bitfield_ty_layout = bitfield_ty + .layout(ctx) .expect("Bitfield without layout? Gah!"); let bitfield_int_ty = BlobTyBuilder::new(bitfield_ty_layout).build(); - let bitfield_ty = bitfield_ty - .to_rust_ty_or_opaque(ctx, bitfield_ty_item); + let bitfield_ty = + bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item); let offset = self.offset_into_unit(); let mask = self.mask(); @@ -1141,20 +1164,22 @@ impl Bitfield { impl<'a> FieldCodegen<'a> for BitfieldUnit { type Extra = (); - fn codegen<F, M>(&self, - ctx: &BindgenContext, - fields_should_be_private: bool, - codegen_depth: usize, - accessor_kind: FieldAccessorKind, - parent: &CompInfo, - anon_field_names: &mut AnonFieldNames, - result: &mut CodegenResult, - struct_layout: &mut StructLayoutTracker, - fields: &mut F, - methods: &mut M, - _: ()) - where F: Extend<ast::StructField>, - M: Extend<ast::ImplItem> + fn codegen<F, M>( + &self, + ctx: &BindgenContext, + fields_should_be_private: bool, + codegen_depth: usize, + accessor_kind: FieldAccessorKind, + parent: &CompInfo, + anon_field_names: &mut AnonFieldNames, + result: &mut CodegenResult, + struct_layout: &mut StructLayoutTracker, + fields: &mut F, + methods: &mut M, + _: (), + ) where + F: Extend<ast::StructField>, + M: Extend<ast::ImplItem>, { let field_ty = BlobTyBuilder::new(self.layout()).build(); let unit_field_name = format!("_bitfield_{}", self.nth()); @@ -1187,30 +1212,34 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit { let mut ctor_impl = self.initial_ctor_impl(ctx, &unit_field_int_ty); for bf in self.bitfields() { - bf.codegen(ctx, - fields_should_be_private, - codegen_depth, - accessor_kind, - parent, - anon_field_names, - result, - struct_layout, - fields, - methods, - (&unit_field_name, unit_field_int_ty.clone())); - - ctor_impl = bf.extend_ctor_impl(ctx, - parent, - ctor_impl, - &ctor_name, - &unit_field_int_ty); + bf.codegen( + ctx, + fields_should_be_private, + codegen_depth, + accessor_kind, + parent, + anon_field_names, + result, + struct_layout, + fields, + methods, + (&unit_field_name, unit_field_int_ty.clone()), + ); + + ctor_impl = bf.extend_ctor_impl( + ctx, + parent, + ctor_impl, + &ctor_name, + &unit_field_int_ty, + ); } match ctor_impl.unwrap().node { ast::ItemKind::Impl(_, _, _, _, _, items) => { assert_eq!(items.len(), 1); methods.extend(items.into_iter()); - }, + } _ => unreachable!(), }; @@ -1218,27 +1247,31 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit { } } -fn parent_has_method(ctx: &BindgenContext, - parent: &CompInfo, - name: &str) - -> bool { +fn parent_has_method( + ctx: &BindgenContext, + parent: &CompInfo, + name: &str, +) -> bool { parent.methods().iter().any(|method| { let method_name = match *ctx.resolve_item(method.signature()).kind() { ItemKind::Function(ref func) => func.name(), - ref otherwise => panic!("a method's signature should always be a \ - item of kind ItemKind::Function, found: \ - {:?}", - otherwise), + ref otherwise => panic!( + "a method's signature should always be a \ + item of kind ItemKind::Function, found: \ + {:?}", + otherwise + ), }; method_name == name || ctx.rust_mangle(&method_name) == name }) } -fn bitfield_getter_name(ctx: &BindgenContext, - parent: &CompInfo, - bitfield_name: &str) - -> ast::Ident { +fn bitfield_getter_name( + ctx: &BindgenContext, + parent: &CompInfo, + bitfield_name: &str, +) -> ast::Ident { let name = ctx.rust_mangle(bitfield_name); if parent_has_method(ctx, parent, &name) { @@ -1250,10 +1283,11 @@ fn bitfield_getter_name(ctx: &BindgenContext, ctx.ext_cx().ident_of(&name) } -fn bitfield_setter_name(ctx: &BindgenContext, - parent: &CompInfo, - bitfield_name: &str) - -> ast::Ident { +fn bitfield_setter_name( + ctx: &BindgenContext, + parent: &CompInfo, + bitfield_name: &str, +) -> ast::Ident { let setter = format!("set_{}", bitfield_name); let mut setter = ctx.rust_mangle(&setter).to_string(); @@ -1267,21 +1301,22 @@ fn bitfield_setter_name(ctx: &BindgenContext, impl<'a> FieldCodegen<'a> for Bitfield { type Extra = (&'a str, P<ast::Ty>); - fn codegen<F, M>(&self, - ctx: &BindgenContext, - _fields_should_be_private: bool, - _codegen_depth: usize, - _accessor_kind: FieldAccessorKind, - parent: &CompInfo, - _anon_field_names: &mut AnonFieldNames, - _result: &mut CodegenResult, - _struct_layout: &mut StructLayoutTracker, - _fields: &mut F, - methods: &mut M, - (unit_field_name, - unit_field_int_ty): (&'a str, P<ast::Ty>)) - where F: Extend<ast::StructField>, - M: Extend<ast::ImplItem> + fn codegen<F, M>( + &self, + ctx: &BindgenContext, + _fields_should_be_private: bool, + _codegen_depth: usize, + _accessor_kind: FieldAccessorKind, + parent: &CompInfo, + _anon_field_names: &mut AnonFieldNames, + _result: &mut CodegenResult, + _struct_layout: &mut StructLayoutTracker, + _fields: &mut F, + methods: &mut M, + (unit_field_name, unit_field_int_ty): (&'a str, P<ast::Ty>), + ) where + F: Extend<ast::StructField>, + M: Extend<ast::ImplItem>, { let prefix = ctx.trait_prefix(); let getter_name = bitfield_getter_name(ctx, parent, self.name()); @@ -1291,11 +1326,13 @@ impl<'a> FieldCodegen<'a> for Bitfield { let bitfield_ty_item = ctx.resolve_item(self.ty()); let bitfield_ty = bitfield_ty_item.expect_type(); - let bitfield_ty_layout = bitfield_ty.layout(ctx) + let bitfield_ty_layout = bitfield_ty + .layout(ctx) .expect("Bitfield without layout? Gah!"); let bitfield_int_ty = BlobTyBuilder::new(bitfield_ty_layout).build(); - let bitfield_ty = bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item); + let bitfield_ty = + bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item); let offset = self.offset_into_unit(); let mask = self.mask(); @@ -1358,7 +1395,7 @@ impl<'a> FieldCodegen<'a> for Bitfield { match impl_item.unwrap().node { ast::ItemKind::Impl(_, _, _, _, _, items) => { methods.extend(items.into_iter()); - }, + } _ => unreachable!(), }; } @@ -1367,10 +1404,12 @@ impl<'a> FieldCodegen<'a> for Bitfield { impl CodeGenerator for CompInfo { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { debug!("<CompInfo as CodeGenerator>::codegen: item = {:?}", item); debug_assert!(item.is_enabled_for_codegen(ctx)); @@ -1403,6 +1442,7 @@ impl CodeGenerator for CompInfo { let mut attributes = vec![]; let mut needs_clone_impl = false; let mut needs_default_impl = false; + let mut needs_debug_impl = false; if let Some(comment) = item.comment(ctx) { attributes.push(attributes::doc(comment)); } @@ -1416,6 +1456,9 @@ impl CodeGenerator for CompInfo { let mut derives = vec![]; if item.can_derive_debug(ctx) { derives.push("Debug"); + } else { + needs_debug_impl = + ctx.options().derive_debug && ctx.options().impl_debug } if item.can_derive_default(ctx) { @@ -1424,8 +1467,7 @@ impl CodeGenerator for CompInfo { needs_default_impl = ctx.options().derive_default; } - if item.can_derive_copy(ctx) && - !item.annotations().disallow_copy() { + if item.can_derive_copy(ctx) && !item.annotations().disallow_copy() { derives.push("Copy"); if used_template_params.is_some() { // FIXME: This requires extra logic if you have a big array in a @@ -1472,13 +1514,15 @@ impl CodeGenerator for CompInfo { // Also, we need to generate the vtable in such a way it "inherits" from // the parent too. let mut fields = vec![]; - let mut struct_layout = StructLayoutTracker::new(ctx, self, &canonical_name); + let mut struct_layout = + StructLayoutTracker::new(ctx, self, &canonical_name); if self.needs_explicit_vtable(ctx, item) { let vtable = Vtable::new(item.id(), self.methods(), self.base_members()); vtable.codegen(ctx, result, item); - let vtable_type = vtable.try_to_rust_ty(ctx, &()) + let vtable_type = vtable + .try_to_rust_ty(ctx, &()) .expect("vtable to Rust type conversion is infallible") .to_ptr(true, ctx.span()); @@ -1517,9 +1561,8 @@ impl CodeGenerator for CompInfo { struct_layout.saw_base(base_ty); - let field = StructFieldBuilder::named(field_name) - .pub_() - .build_ty(inner); + let field = + StructFieldBuilder::named(field_name).pub_().build_ty(inner); fields.extend(Some(field)); } if is_union { @@ -1528,9 +1571,8 @@ impl CodeGenerator for CompInfo { let layout = item.kind().expect_type().layout(ctx); - let fields_should_be_private = item.annotations() - .private_fields() - .unwrap_or(false); + let fields_should_be_private = + item.annotations().private_fields().unwrap_or(false); let struct_accessor_kind = item.annotations() .accessor_kind() .unwrap_or(FieldAccessorKind::None); @@ -1539,17 +1581,19 @@ impl CodeGenerator for CompInfo { let mut anon_field_names = AnonFieldNames::default(); let codegen_depth = item.codegen_depth(ctx); for field in self.fields() { - field.codegen(ctx, - fields_should_be_private, - codegen_depth, - struct_accessor_kind, - self, - &mut anon_field_names, - result, - &mut struct_layout, - &mut fields, - &mut methods, - ()); + field.codegen( + ctx, + fields_should_be_private, + codegen_depth, + struct_accessor_kind, + self, + &mut anon_field_names, + result, + &mut struct_layout, + &mut fields, + &mut methods, + (), + ); } if is_union && !ctx.options().unstable_rust { @@ -1573,10 +1617,10 @@ impl CodeGenerator for CompInfo { match layout { Some(l) => { let ty = BlobTyBuilder::new(l).build(); - let field = - StructFieldBuilder::named("_bindgen_opaque_blob") - .pub_() - .build_ty(ty); + let field = StructFieldBuilder::named( + "_bindgen_opaque_blob", + ).pub_() + .build_ty(ty); fields.push(field); } None => { @@ -1585,14 +1629,14 @@ impl CodeGenerator for CompInfo { } } else if !is_union && !self.is_unsized(ctx, &item.id()) { if let Some(padding_field) = - layout.and_then(|layout| { - struct_layout.pad_struct(layout) - }) { + layout.and_then(|layout| struct_layout.pad_struct(layout)) + { fields.push(padding_field); } if let Some(align_field) = - layout.and_then(|layout| struct_layout.align_struct(layout)) { + layout.and_then(|layout| struct_layout.align_struct(layout)) + { fields.push(align_field); } } @@ -1618,9 +1662,8 @@ impl CodeGenerator for CompInfo { if has_address { let ty = BlobTyBuilder::new(Layout::new(1, 1)).build(); - let field = StructFieldBuilder::named("_address") - .pub_() - .build_ty(ty); + let field = + StructFieldBuilder::named("_address").pub_().build_ty(ty); fields.push(field); } } @@ -1639,8 +1682,9 @@ impl CodeGenerator for CompInfo { let phantom_ty = quote_ty!( ctx.ext_cx(), ::$prefix::marker::PhantomData<::$prefix::cell::UnsafeCell<$ident>>); - let phantom_field = StructFieldBuilder::named(format!("_phantom_{}", idx)) - .pub_() + let phantom_field = StructFieldBuilder::named( + format!("_phantom_{}", idx), + ).pub_() .build_ty(phantom_ty); fields.push(phantom_field); } @@ -1648,7 +1692,8 @@ impl CodeGenerator for CompInfo { let generics = generics.build(); - let rust_struct = builder.with_generics(generics.clone()) + let rust_struct = builder + .with_generics(generics.clone()) .with_fields(fields) .build(); result.push(rust_struct); @@ -1667,21 +1712,23 @@ impl CodeGenerator for CompInfo { // affect layout, so we're bad and pray to the gods for avoid sending // all the tests to shit when parsing things like max_align_t. if self.found_unknown_attr() { - warn!("Type {} has an unkown attribute that may affect layout", - canonical_name); + warn!( + "Type {} has an unkown attribute that may affect layout", + canonical_name + ); } if used_template_params.is_none() { if !is_opaque { for var in self.inner_vars() { - ctx.resolve_item(*var) - .codegen(ctx, result, &()); + ctx.resolve_item(*var).codegen(ctx, result, &()); } } if ctx.options().layout_tests { if let Some(layout) = layout { - let fn_name = format!("bindgen_test_layout_{}", canonical_name); + let fn_name = + format!("bindgen_test_layout_{}", canonical_name); let fn_name = ctx.rust_ident_raw(&fn_name); let type_name = ctx.rust_ident_raw(&canonical_name); let prefix = ctx.trait_prefix(); @@ -1692,32 +1739,33 @@ impl CodeGenerator for CompInfo { let size = layout.size; let align = layout.align; - let check_struct_align = if align > mem::size_of::<*mut ()>() { - // FIXME when [RFC 1358](https://github.com/rust-lang/rust/issues/33626) ready - None - } else { - quote_item!(ctx.ext_cx(), + let check_struct_align = + if align > mem::size_of::<*mut ()>() { + // FIXME when [RFC 1358](https://github.com/rust-lang/rust/issues/33626) ready + None + } else { + quote_item!(ctx.ext_cx(), assert_eq!($align_of_expr, $align, concat!("Alignment of ", stringify!($type_name))); ) - }; + }; // FIXME when [issue #465](https://github.com/rust-lang-nursery/rust-bindgen/issues/465) ready let too_many_base_vtables = self.base_members() .iter() - .filter(|base| { - ctx.lookup_item_id_has_vtable(&base.ty) - }) - .count() > 1; + .filter(|base| ctx.lookup_item_id_has_vtable(&base.ty)) + .count() > + 1; let should_skip_field_offset_checks = is_opaque || too_many_base_vtables; - let check_field_offset = if should_skip_field_offset_checks { - None - } else { - let asserts = self.fields() + let check_field_offset = + if should_skip_field_offset_checks { + None + } else { + let asserts = self.fields() .iter() .filter_map(|field| match *field { Field::DataMember(ref f) if f.name().is_some() => Some(f), @@ -1738,8 +1786,8 @@ impl CodeGenerator for CompInfo { }) .collect::<Vec<P<ast::Item>>>(); - Some(asserts) - }; + Some(asserts) + }; let item = quote_item!(ctx.ext_cx(), #[test] @@ -1760,25 +1808,30 @@ impl CodeGenerator for CompInfo { if ctx.options().codegen_config.methods { for method in self.methods() { assert!(method.kind() != MethodKind::Constructor); - method.codegen_method(ctx, - &mut methods, - &mut method_names, - result, - self); + method.codegen_method( + ctx, + &mut methods, + &mut method_names, + result, + self, + ); } } if ctx.options().codegen_config.constructors { for sig in self.constructors() { - Method::new(MethodKind::Constructor, - *sig, - /* const */ - false) - .codegen_method(ctx, - &mut methods, - &mut method_names, - result, - self); + Method::new( + MethodKind::Constructor, + *sig, + /* const */ + false, + ).codegen_method( + ctx, + &mut methods, + &mut method_names, + result, + self, + ); } } @@ -1790,12 +1843,13 @@ impl CodeGenerator for CompInfo { MethodKind::Destructor }; - Method::new(kind, destructor, false) - .codegen_method(ctx, - &mut methods, - &mut method_names, - result, - self); + Method::new(kind, destructor, false).codegen_method( + ctx, + &mut methods, + &mut method_names, + result, + self, + ); } } } @@ -1861,6 +1915,27 @@ impl CodeGenerator for CompInfo { result.push(default_impl); } + if needs_debug_impl { + let impl_ = derive_debug::gen_debug_impl( + ctx, + self.fields(), + item, + self.kind(), + ); + + let debug_impl = aster::AstBuilder::new() + .item() + .impl_() + .trait_() + .id("::std::fmt::Debug") + .build() + .with_generics(generics.clone()) + .with_items(impl_) + .build_ty(ty_for_impl.clone()); + + result.push(debug_impl); + } + if !methods.is_empty() { let methods = aster::AstBuilder::new() .item() @@ -1874,30 +1949,34 @@ impl CodeGenerator for CompInfo { } trait MethodCodegen { - fn codegen_method<'a>(&self, - ctx: &BindgenContext, - methods: &mut Vec<ast::ImplItem>, - method_names: &mut HashMap<String, usize>, - result: &mut CodegenResult<'a>, - parent: &CompInfo); + fn codegen_method<'a>( + &self, + ctx: &BindgenContext, + methods: &mut Vec<ast::ImplItem>, + method_names: &mut HashMap<String, usize>, + result: &mut CodegenResult<'a>, + parent: &CompInfo, + ); } impl MethodCodegen for Method { - fn codegen_method<'a>(&self, - ctx: &BindgenContext, - methods: &mut Vec<ast::ImplItem>, - method_names: &mut HashMap<String, usize>, - result: &mut CodegenResult<'a>, - _parent: &CompInfo) { + fn codegen_method<'a>( + &self, + ctx: &BindgenContext, + methods: &mut Vec<ast::ImplItem>, + method_names: &mut HashMap<String, usize>, + result: &mut CodegenResult<'a>, + _parent: &CompInfo, + ) { assert!({ let cc = &ctx.options().codegen_config; match self.kind() { MethodKind::Constructor => cc.constructors, MethodKind::Destructor => cc.destructors, MethodKind::VirtualDestructor => cc.destructors, - MethodKind::Static | - MethodKind::Normal | - MethodKind::Virtual => cc.methods, + MethodKind::Static | MethodKind::Normal | MethodKind::Virtual => { + cc.methods + } } }); @@ -1929,8 +2008,7 @@ impl MethodCodegen for Method { } let count = { - let mut count = method_names.entry(name.clone()) - .or_insert(0); + let mut count = method_names.entry(name.clone()).or_insert(0); *count += 1; *count - 1 }; @@ -1940,8 +2018,8 @@ impl MethodCodegen for Method { } let function_name = function_item.canonical_name(ctx); - let mut fndecl = utils::rust_fndecl_from_signature(ctx, signature_item) - .unwrap(); + let mut fndecl = + utils::rust_fndecl_from_signature(ctx, signature_item).unwrap(); if !self.is_static() && !self.is_constructor() { let mutability = if self.is_const() { ast::Mutability::Immutable @@ -1955,14 +2033,17 @@ impl MethodCodegen for Method { fndecl.inputs[0] = ast::Arg { ty: P(ast::Ty { id: ast::DUMMY_NODE_ID, - node: ast::TyKind::Rptr(None, ast::MutTy { - ty: P(ast::Ty { - id: ast::DUMMY_NODE_ID, - node: ast::TyKind::ImplicitSelf, - span: ctx.span() - }), - mutbl: mutability, - }), + node: ast::TyKind::Rptr( + None, + ast::MutTy { + ty: P(ast::Ty { + id: ast::DUMMY_NODE_ID, + node: ast::TyKind::ImplicitSelf, + span: ctx.span(), + }), + mutbl: mutability, + }, + ), span: ctx.span(), }), pat: P(ast::Pat { @@ -1970,7 +2051,7 @@ impl MethodCodegen for Method { node: ast::PatKind::Ident( ast::BindingMode::ByValue(ast::Mutability::Immutable), respan(ctx.span(), ctx.ext_cx().ident_of("self")), - None + None, ), span: ctx.span(), }), @@ -1985,8 +2066,8 @@ impl MethodCodegen for Method { // return-type = void. if self.is_constructor() { fndecl.inputs.remove(0); - fndecl.output = ast::FunctionRetTy::Ty(quote_ty!(ctx.ext_cx(), - Self)); + fndecl.output = + ast::FunctionRetTy::Ty(quote_ty!(ctx.ext_cx(), Self)); } let sig = ast::MethodSig { @@ -1997,8 +2078,8 @@ impl MethodCodegen for Method { constness: respan(ctx.span(), ast::Constness::NotConst), }; - let mut exprs = helpers::ast_ty::arguments_from_signature(&signature, - ctx); + let mut exprs = + helpers::ast_ty::arguments_from_signature(&signature, ctx); let mut stmts = vec![]; @@ -2074,17 +2155,19 @@ enum EnumBuilder<'a> { impl<'a> EnumBuilder<'a> { /// Create a new enum given an item builder, a canonical name, a name for /// the representation, and whether it should be represented as a rust enum. - fn new(aster: aster::item::ItemBuilder<aster::invoke::Identity>, - name: &'a str, - repr: P<ast::Ty>, - bitfield_like: bool, - constify: bool, - constify_module: bool) - -> Self { + fn new( + aster: aster::item::ItemBuilder<aster::invoke::Identity>, + name: &'a str, + repr: P<ast::Ty>, + bitfield_like: bool, + constify: bool, + constify_module: bool, + ) -> Self { if bitfield_like { EnumBuilder::Bitfield { canonical_name: name, - aster: aster.tuple_struct(name) + aster: aster + .tuple_struct(name) .field() .pub_() .build_ty(repr) @@ -2101,7 +2184,7 @@ impl<'a> EnumBuilder<'a> { module_name: name, module_items: vec![type_definition], } - } else { + } else { EnumBuilder::Consts { aster: aster.type_(name).build_ty(repr), } @@ -2112,13 +2195,14 @@ impl<'a> EnumBuilder<'a> { } /// Add a variant to this enum. - fn with_variant<'b>(self, - ctx: &BindgenContext, - variant: &EnumVariant, - mangling_prefix: Option<&String>, - rust_ty: P<ast::Ty>, - result: &mut CodegenResult<'b>) - -> Self { + fn with_variant<'b>( + self, + ctx: &BindgenContext, + variant: &EnumVariant, + mangling_prefix: Option<&String>, + rust_ty: P<ast::Ty>, + result: &mut CodegenResult<'b>, + ) -> Self { let variant_name = ctx.rust_mangle(variant.name()); let expr = aster::AstBuilder::new().expr(); let expr = match variant.val() { @@ -2135,7 +2219,9 @@ impl<'a> EnumBuilder<'a> { disr_expr: Some(expr), })) } - EnumBuilder::Bitfield { canonical_name, .. } => { + EnumBuilder::Bitfield { + canonical_name, .. + } => { let constant_name = match mangling_prefix { Some(prefix) => { Cow::Owned(format!("{}_{}", prefix, variant_name)) @@ -2157,7 +2243,9 @@ impl<'a> EnumBuilder<'a> { result.push(constant); self } - EnumBuilder::Consts { .. } => { + EnumBuilder::Consts { + .. + } => { let constant_name = match mangling_prefix { Some(prefix) => { Cow::Owned(format!("{}_{}", prefix, variant_name)) @@ -2176,10 +2264,15 @@ impl<'a> EnumBuilder<'a> { result.push(constant); self } - EnumBuilder::ModuleConsts { module_name, module_items, .. } => { + EnumBuilder::ModuleConsts { + module_name, + module_items, + .. + } => { // Variant type - let inside_module_type = - aster::AstBuilder::new().ty().id(CONSTIFIED_ENUM_MODULE_REPR_NAME); + let inside_module_type = aster::AstBuilder::new() + .ty() + .id(CONSTIFIED_ENUM_MODULE_REPR_NAME); let constant = aster::AstBuilder::new() .item() @@ -2200,14 +2293,18 @@ impl<'a> EnumBuilder<'a> { } } - fn build<'b>(self, - ctx: &BindgenContext, - rust_ty: P<ast::Ty>, - result: &mut CodegenResult<'b>) - -> P<ast::Item> { + fn build<'b>( + self, + ctx: &BindgenContext, + rust_ty: P<ast::Ty>, + result: &mut CodegenResult<'b>, + ) -> P<ast::Item> { match self { EnumBuilder::Rust(b) => b.build(), - EnumBuilder::Bitfield { canonical_name, aster } => { + EnumBuilder::Bitfield { + canonical_name, + aster, + } => { let rust_ty_name = ctx.rust_ident_raw(canonical_name); let prefix = ctx.trait_prefix(); @@ -2220,8 +2317,7 @@ impl<'a> EnumBuilder<'a> { $rust_ty_name(self.0 | other.0) } } - ) - .unwrap(); + ).unwrap(); result.push(impl_); let impl_ = quote_item!(ctx.ext_cx(), @@ -2231,8 +2327,7 @@ impl<'a> EnumBuilder<'a> { self.0 |= rhs.0; } } - ) - .unwrap(); + ).unwrap(); result.push(impl_); let impl_ = quote_item!(ctx.ext_cx(), @@ -2244,8 +2339,7 @@ impl<'a> EnumBuilder<'a> { $rust_ty_name(self.0 & other.0) } } - ) - .unwrap(); + ).unwrap(); result.push(impl_); let impl_ = quote_item!(ctx.ext_cx(), @@ -2255,14 +2349,19 @@ impl<'a> EnumBuilder<'a> { self.0 &= rhs.0; } } - ) - .unwrap(); + ).unwrap(); result.push(impl_); aster } - EnumBuilder::Consts { aster, .. } => aster, - EnumBuilder::ModuleConsts { module_items, module_name, .. } => { + EnumBuilder::Consts { + aster, .. + } => aster, + EnumBuilder::ModuleConsts { + module_items, + module_name, + .. + } => { // Create module item with type and variant definitions let module_item = P(ast::Item { ident: ast::Ident::from_str(module_name), @@ -2285,10 +2384,12 @@ impl<'a> EnumBuilder<'a> { impl CodeGenerator for Enum { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { debug!("<Enum as CodeGenerator>::codegen: item = {:?}", item); debug_assert!(item.is_enabled_for_codegen(ctx)); @@ -2298,21 +2399,22 @@ impl CodeGenerator for Enum { let repr = self.repr().map(|repr| ctx.resolve_type(repr)); let repr = match repr { - Some(repr) => { - match *repr.canonical_type(ctx).kind() { - TypeKind::Int(int_kind) => int_kind, - _ => panic!("Unexpected type as enum repr"), - } - } + Some(repr) => match *repr.canonical_type(ctx).kind() { + TypeKind::Int(int_kind) => int_kind, + _ => panic!("Unexpected type as enum repr"), + }, None => { - warn!("Guessing type of enum! Forward declarations of enums \ - shouldn't be legal!"); + warn!( + "Guessing type of enum! Forward declarations of enums \ + shouldn't be legal!" + ); IntKind::Int } }; let signed = repr.is_signed(); - let size = layout.map(|l| l.size) + let size = layout + .map(|l| l.size) .or_else(|| repr.known_size()) .unwrap_or(0); @@ -2337,21 +2439,22 @@ impl CodeGenerator for Enum { // disambiguate between namespaces, just like is_opaque etc. let is_bitfield = { ctx.options().bitfield_enums.matches(&name) || - (enum_ty.name().is_none() && - self.variants() - .iter() - .any(|v| ctx.options().bitfield_enums.matches(&v.name()))) + (enum_ty.name().is_none() && + self.variants().iter().any( + |v| ctx.options().bitfield_enums.matches(&v.name()), + )) }; - let is_constified_enum_module = self.is_constified_enum_module(ctx, item); + let is_constified_enum_module = + self.is_constified_enum_module(ctx, item); - let is_constified_enum = { + let is_constified_enum = { is_constified_enum_module || - ctx.options().constified_enums.matches(&name) || - (enum_ty.name().is_none() && - self.variants() - .iter() - .any(|v| ctx.options().constified_enums.matches(&v.name()))) + ctx.options().constified_enums.matches(&name) || + (enum_ty.name().is_none() && + self.variants().iter().any( + |v| ctx.options().constified_enums.matches(&v.name()), + )) }; let is_rust_enum = !is_bitfield && !is_constified_enum; @@ -2373,27 +2476,26 @@ impl CodeGenerator for Enum { } if !is_constified_enum { - let derives = attributes::derives(&["Debug", - "Copy", - "Clone", - "PartialEq", - "Eq", - "Hash"]); + let derives = attributes::derives( + &["Debug", "Copy", "Clone", "PartialEq", "Eq", "Hash"], + ); builder = builder.with_attr(derives); } - fn add_constant<'a>(ctx: &BindgenContext, - enum_: &Type, - // Only to avoid recomputing every time. - enum_canonical_name: &str, - // 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: &str, - enum_rust_ty: P<ast::Ty>, - result: &mut CodegenResult<'a>) { + fn add_constant<'a>( + ctx: &BindgenContext, + enum_: &Type, + // Only to avoid recomputing every time. + enum_canonical_name: &str, + // 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: &str, + enum_rust_ty: P<ast::Ty>, + result: &mut CodegenResult<'a>, + ) { let constant_name = if enum_.name().is_some() { if ctx.options().prepend_enum_name { format!("{}_{}", enum_canonical_name, variant_name) @@ -2420,12 +2522,14 @@ impl CodeGenerator for Enum { .and_then(|repr| repr.try_to_rust_ty_or_opaque(ctx, &()).ok()) .unwrap_or_else(|| helpers::ast_ty::raw_type(ctx, repr_name)); - let mut builder = EnumBuilder::new(builder, - &name, - repr, - is_bitfield, - is_constified_enum, - is_constified_enum_module); + let mut builder = EnumBuilder::new( + builder, + &name, + repr, + is_bitfield, + is_constified_enum, + is_constified_enum_module, + ); // A map where we keep a value -> variant relation. let mut seen_values = HashMap::<_, String>::new(); @@ -2455,8 +2559,9 @@ impl CodeGenerator for Enum { let mut constified_variants = VecDeque::new(); let mut iter = self.variants().iter().peekable(); - while let Some(variant) = iter.next() - .or_else(|| constified_variants.pop_front()) { + while let Some(variant) = + iter.next().or_else(|| constified_variants.pop_front()) + { if variant.hidden() { continue; } @@ -2467,43 +2572,46 @@ impl CodeGenerator for Enum { } match seen_values.entry(variant.val()) { - Entry::Occupied(ref entry) => { - if is_rust_enum { - let variant_name = ctx.rust_mangle(variant.name()); - let mangled_name = if is_toplevel || - enum_ty.name().is_some() { - variant_name - } else { - let parent_name = parent_canonical_name.as_ref() - .unwrap(); + Entry::Occupied(ref entry) => if is_rust_enum { + let variant_name = ctx.rust_mangle(variant.name()); + let mangled_name = if is_toplevel || + enum_ty.name().is_some() + { + variant_name + } else { + let parent_name = + parent_canonical_name.as_ref().unwrap(); - Cow::Owned(format!("{}_{}", - parent_name, - variant_name)) - }; + Cow::Owned(format!("{}_{}", parent_name, variant_name)) + }; - let existing_variant_name = entry.get(); - add_constant(ctx, - enum_ty, - &name, - &*mangled_name, - existing_variant_name, - enum_rust_ty.clone(), - result); - } else { - builder = builder.with_variant(ctx, - variant, - constant_mangling_prefix, - enum_rust_ty.clone(), - result); - } - } + let existing_variant_name = entry.get(); + add_constant( + ctx, + enum_ty, + &name, + &*mangled_name, + existing_variant_name, + enum_rust_ty.clone(), + result, + ); + } else { + builder = builder.with_variant( + ctx, + variant, + constant_mangling_prefix, + enum_rust_ty.clone(), + result, + ); + }, Entry::Vacant(entry) => { - builder = builder.with_variant(ctx, - variant, - constant_mangling_prefix, - enum_rust_ty.clone(), - result); + builder = builder.with_variant( + ctx, + variant, + constant_mangling_prefix, + enum_rust_ty.clone(), + result, + ); let variant_name = ctx.rust_mangle(variant.name()); @@ -2511,25 +2619,28 @@ impl CodeGenerator for Enum { // we also generate a constant so it can be properly // accessed. if (is_rust_enum && enum_ty.name().is_none()) || - variant.force_constification() { + variant.force_constification() + { let mangled_name = if is_toplevel { variant_name.clone() } else { - let parent_name = parent_canonical_name.as_ref() - .unwrap(); + let parent_name = + parent_canonical_name.as_ref().unwrap(); - Cow::Owned(format!("{}_{}", - parent_name, - variant_name)) + Cow::Owned( + format!("{}_{}", parent_name, variant_name), + ) }; - add_constant(ctx, - enum_ty, - &name, - &mangled_name, - &variant_name, - enum_rust_ty.clone(), - result); + add_constant( + ctx, + enum_ty, + &name, + &mangled_name, + &variant_name, + enum_rust_ty.clone(), + result, + ); } entry.insert(variant_name.into_owned()); @@ -2551,16 +2662,18 @@ trait TryToOpaque { type Extra; /// Get the layout for this thing, if one is available. - fn try_get_layout(&self, - ctx: &BindgenContext, - extra: &Self::Extra) - -> error::Result<Layout>; + fn try_get_layout( + &self, + ctx: &BindgenContext, + extra: &Self::Extra, + ) -> error::Result<Layout>; /// Do not override this provided trait method. - fn try_to_opaque(&self, - ctx: &BindgenContext, - extra: &Self::Extra) - -> error::Result<P<ast::Ty>> { + fn try_to_opaque( + &self, + ctx: &BindgenContext, + extra: &Self::Extra, + ) -> error::Result<P<ast::Ty>> { self.try_get_layout(ctx, extra) .map(|layout| BlobTyBuilder::new(layout).build()) } @@ -2577,26 +2690,26 @@ trait TryToOpaque { /// Don't implement this directly. Instead implement `TryToOpaque`, and then /// leverage the blanket impl for this trait. trait ToOpaque: TryToOpaque { - fn get_layout(&self, - ctx: &BindgenContext, - extra: &Self::Extra) - -> Layout { + fn get_layout(&self, ctx: &BindgenContext, extra: &Self::Extra) -> Layout { self.try_get_layout(ctx, extra) .unwrap_or_else(|_| Layout::for_size(1)) } - fn to_opaque(&self, - ctx: &BindgenContext, - extra: &Self::Extra) - -> P<ast::Ty> { + fn to_opaque( + &self, + ctx: &BindgenContext, + extra: &Self::Extra, + ) -> P<ast::Ty> { let layout = self.get_layout(ctx, extra); BlobTyBuilder::new(layout).build() } } impl<T> ToOpaque for T - where T: TryToOpaque -{} +where + T: TryToOpaque, +{ +} /// Fallible conversion from an IR thing to an *equivalent* Rust type. /// @@ -2608,10 +2721,11 @@ impl<T> ToOpaque for T trait TryToRustTy { type Extra; - fn try_to_rust_ty(&self, - ctx: &BindgenContext, - extra: &Self::Extra) - -> error::Result<P<ast::Ty>>; + fn try_to_rust_ty( + &self, + ctx: &BindgenContext, + extra: &Self::Extra, + ) -> error::Result<P<ast::Ty>>; } /// Fallible conversion to a Rust type or an opaque blob with the correct size @@ -2622,29 +2736,31 @@ trait TryToRustTy { trait TryToRustTyOrOpaque: TryToRustTy + TryToOpaque { type Extra; - fn try_to_rust_ty_or_opaque(&self, - ctx: &BindgenContext, - extra: &<Self as TryToRustTyOrOpaque>::Extra) - -> error::Result<P<ast::Ty>>; + fn try_to_rust_ty_or_opaque( + &self, + ctx: &BindgenContext, + extra: &<Self as TryToRustTyOrOpaque>::Extra, + ) -> error::Result<P<ast::Ty>>; } impl<E, T> TryToRustTyOrOpaque for T - where T: TryToRustTy<Extra=E> + TryToOpaque<Extra=E> +where + T: TryToRustTy<Extra = E> + TryToOpaque<Extra = E>, { type Extra = E; - fn try_to_rust_ty_or_opaque(&self, - ctx: &BindgenContext, - extra: &E) - -> error::Result<P<ast::Ty>> { - self.try_to_rust_ty(ctx, extra) - .or_else(|_| { - if let Ok(layout) = self.try_get_layout(ctx, extra) { - Ok(BlobTyBuilder::new(layout).build()) - } else { - Err(error::Error::NoLayoutForOpaqueBlob) - } - }) + fn try_to_rust_ty_or_opaque( + &self, + ctx: &BindgenContext, + extra: &E, + ) -> error::Result<P<ast::Ty>> { + self.try_to_rust_ty(ctx, extra).or_else( + |_| if let Ok(layout) = self.try_get_layout(ctx, extra) { + Ok(BlobTyBuilder::new(layout).build()) + } else { + Err(error::Error::NoLayoutForOpaqueBlob) + }, + ) } } @@ -2668,21 +2784,24 @@ impl<E, T> TryToRustTyOrOpaque for T trait ToRustTyOrOpaque: TryToRustTy + ToOpaque { type Extra; - fn to_rust_ty_or_opaque(&self, - ctx: &BindgenContext, - extra: &<Self as ToRustTyOrOpaque>::Extra) - -> P<ast::Ty>; + fn to_rust_ty_or_opaque( + &self, + ctx: &BindgenContext, + extra: &<Self as ToRustTyOrOpaque>::Extra, + ) -> P<ast::Ty>; } impl<E, T> ToRustTyOrOpaque for T - where T: TryToRustTy<Extra=E> + ToOpaque<Extra=E> +where + T: TryToRustTy<Extra = E> + ToOpaque<Extra = E>, { type Extra = E; - fn to_rust_ty_or_opaque(&self, - ctx: &BindgenContext, - extra: &E) - -> P<ast::Ty> { + fn to_rust_ty_or_opaque( + &self, + ctx: &BindgenContext, + extra: &E, + ) -> P<ast::Ty> { self.try_to_rust_ty(ctx, extra) .unwrap_or_else(|_| self.to_opaque(ctx, extra)) } @@ -2691,10 +2810,11 @@ impl<E, T> ToRustTyOrOpaque for T impl TryToOpaque for ItemId { type Extra = (); - fn try_get_layout(&self, - ctx: &BindgenContext, - _: &()) - -> error::Result<Layout> { + fn try_get_layout( + &self, + ctx: &BindgenContext, + _: &(), + ) -> error::Result<Layout> { ctx.resolve_item(*self).try_get_layout(ctx, &()) } } @@ -2702,10 +2822,11 @@ impl TryToOpaque for ItemId { impl TryToRustTy for ItemId { type Extra = (); - fn try_to_rust_ty(&self, - ctx: &BindgenContext, - _: &()) - -> error::Result<P<ast::Ty>> { + fn try_to_rust_ty( + &self, + ctx: &BindgenContext, + _: &(), + ) -> error::Result<P<ast::Ty>> { ctx.resolve_item(*self).try_to_rust_ty(ctx, &()) } } @@ -2713,10 +2834,11 @@ impl TryToRustTy for ItemId { impl TryToOpaque for Item { type Extra = (); - fn try_get_layout(&self, - ctx: &BindgenContext, - _: &()) - -> error::Result<Layout> { + fn try_get_layout( + &self, + ctx: &BindgenContext, + _: &(), + ) -> error::Result<Layout> { self.kind().expect_type().try_get_layout(ctx, self) } } @@ -2724,10 +2846,11 @@ impl TryToOpaque for Item { impl TryToRustTy for Item { type Extra = (); - fn try_to_rust_ty(&self, - ctx: &BindgenContext, - _: &()) - -> error::Result<P<ast::Ty>> { + fn try_to_rust_ty( + &self, + ctx: &BindgenContext, + _: &(), + ) -> error::Result<P<ast::Ty>> { self.kind().expect_type().try_to_rust_ty(ctx, self) } } @@ -2735,10 +2858,11 @@ impl TryToRustTy for Item { impl TryToOpaque for Type { type Extra = Item; - fn try_get_layout(&self, - ctx: &BindgenContext, - _: &Item) - -> error::Result<Layout> { + fn try_get_layout( + &self, + ctx: &BindgenContext, + _: &Item, + ) -> error::Result<Layout> { self.layout(ctx).ok_or(error::Error::NoLayoutForOpaqueBlob) } } @@ -2746,10 +2870,11 @@ impl TryToOpaque for Type { impl TryToRustTy for Type { type Extra = Item; - fn try_to_rust_ty(&self, - ctx: &BindgenContext, - item: &Item) - -> error::Result<P<ast::Ty>> { + fn try_to_rust_ty( + &self, + ctx: &BindgenContext, + item: &Item, + ) -> error::Result<P<ast::Ty>> { use self::helpers::ast_ty::*; match *self.kind() { @@ -2762,7 +2887,9 @@ impl TryToRustTy for Type { TypeKind::Int(ik) => { match ik { IntKind::Bool => Ok(aster::ty::TyBuilder::new().bool()), - IntKind::Char { .. } => Ok(raw_type(ctx, "c_char")), + IntKind::Char { + .. + } => Ok(raw_type(ctx, "c_char")), IntKind::SChar => Ok(raw_type(ctx, "c_schar")), IntKind::UChar => Ok(raw_type(ctx, "c_uchar")), IntKind::Short => Ok(raw_type(ctx, "c_short")), @@ -2782,7 +2909,9 @@ impl TryToRustTy for Type { IntKind::U32 => Ok(aster::ty::TyBuilder::new().u32()), IntKind::I64 => Ok(aster::ty::TyBuilder::new().i64()), IntKind::U64 => Ok(aster::ty::TyBuilder::new().u64()), - IntKind::Custom { name, .. } => { + IntKind::Custom { + name, .. + } => { let ident = ctx.rust_ident_raw(name); Ok(quote_ty!(ctx.ext_cx(), $ident)) } @@ -2821,18 +2950,13 @@ impl TryToRustTy for Type { } TypeKind::Enum(..) => { let path = item.namespace_aware_canonical_path(ctx); - Ok(aster::AstBuilder::new() - .ty() - .path() - .ids(path) - .build()) + Ok(aster::AstBuilder::new().ty().path().ids(path).build()) } TypeKind::TemplateInstantiation(ref inst) => { inst.try_to_rust_ty(ctx, item) } TypeKind::ResolvedTypeRef(inner) => inner.try_to_rust_ty(ctx, &()), - TypeKind::TemplateAlias(inner, _) | - TypeKind::Alias(inner) => { + TypeKind::TemplateAlias(inner, _) | TypeKind::Alias(inner) => { let template_params = item.used_template_params(ctx) .unwrap_or(vec![]) .into_iter() @@ -2842,9 +2966,9 @@ impl TryToRustTy for Type { let spelling = self.name().expect("Unnamed alias?"); if item.is_opaque(ctx, &()) && !template_params.is_empty() { self.try_to_opaque(ctx, item) - } else if let Some(ty) = utils::type_from_named(ctx, - spelling, - inner) { + } else if let Some(ty) = + utils::type_from_named(ctx, spelling, inner) + { Ok(ty) } else { utils::build_templated_path(item, ctx, template_params) @@ -2853,26 +2977,24 @@ impl TryToRustTy for Type { TypeKind::Comp(ref info) => { let template_params = item.used_template_params(ctx); if info.has_non_type_template_params() || - (item.is_opaque(ctx, &()) && template_params.is_some()) { + (item.is_opaque(ctx, &()) && template_params.is_some()) + { return self.try_to_opaque(ctx, item); } let template_params = template_params.unwrap_or(vec![]); - utils::build_templated_path(item, - ctx, - template_params) - } - TypeKind::Opaque => { - self.try_to_opaque(ctx, item) + utils::build_templated_path(item, ctx, template_params) } + TypeKind::Opaque => self.try_to_opaque(ctx, item), TypeKind::BlockPointer => { let void = raw_type(ctx, "c_void"); - Ok(void.to_ptr(/* is_const = */ - false, - ctx.span())) + Ok(void.to_ptr( + /* is_const = */ + false, + ctx.span(), + )) } - TypeKind::Pointer(inner) | - TypeKind::Reference(inner) => { + TypeKind::Pointer(inner) | TypeKind::Reference(inner) => { let inner = ctx.resolve_item(inner); let inner_ty = inner.expect_type(); @@ -2886,8 +3008,8 @@ impl TryToRustTy for Type { if inner_ty.canonical_type(ctx).is_function() { Ok(ty) } else { - let is_const = self.is_const() || - inner.expect_type().is_const(); + let is_const = + self.is_const() || inner.expect_type().is_const(); Ok(ty.to_ptr(is_const, ctx.span())) } } @@ -2896,9 +3018,12 @@ impl TryToRustTy for Type { let ident = ctx.rust_ident(&name); Ok(quote_ty!(ctx.ext_cx(), $ident)) } - TypeKind::ObjCSel => Ok(quote_ty!(ctx.ext_cx(), objc::runtime::Sel)), - TypeKind::ObjCId | - TypeKind::ObjCInterface(..) => Ok(quote_ty!(ctx.ext_cx(), id)), + TypeKind::ObjCSel => { + Ok(quote_ty!(ctx.ext_cx(), objc::runtime::Sel)) + } + TypeKind::ObjCId | TypeKind::ObjCInterface(..) => { + Ok(quote_ty!(ctx.ext_cx(), id)) + } ref u @ TypeKind::UnresolvedTypeRef(..) => { unreachable!("Should have been resolved after parsing {:?}!", u) } @@ -2909,21 +3034,25 @@ impl TryToRustTy for Type { impl TryToOpaque for TemplateInstantiation { type Extra = Item; - fn try_get_layout(&self, - ctx: &BindgenContext, - item: &Item) - -> error::Result<Layout> { - item.expect_type().layout(ctx).ok_or(error::Error::NoLayoutForOpaqueBlob) + fn try_get_layout( + &self, + ctx: &BindgenContext, + item: &Item, + ) -> error::Result<Layout> { + item.expect_type() + .layout(ctx) + .ok_or(error::Error::NoLayoutForOpaqueBlob) } } impl TryToRustTy for TemplateInstantiation { type Extra = Item; - fn try_to_rust_ty(&self, - ctx: &BindgenContext, - item: &Item) - -> error::Result<P<ast::Ty>> { + fn try_to_rust_ty( + &self, + ctx: &BindgenContext, + item: &Item, + ) -> error::Result<P<ast::Ty>> { if self.is_opaque(ctx, item) { return Err(error::Error::InstantiationOfOpaqueType); } @@ -2937,10 +3066,12 @@ impl TryToRustTy for TemplateInstantiation { // This can happen if we generated an opaque type for a partial // template specialization, and we've hit an instantiation of // that partial specialization. - extra_assert!(decl.into_resolver() - .through_type_refs() - .resolve(ctx) - .is_opaque(ctx, &())); + extra_assert!( + decl.into_resolver() + .through_type_refs() + .resolve(ctx) + .is_opaque(ctx, &()) + ); return Err(error::Error::InstantiationOfOpaqueType); } }; @@ -2963,18 +3094,18 @@ impl TryToRustTy for TemplateInstantiation { .map(|(arg, _)| arg.try_to_rust_ty(ctx, &())) .collect::<error::Result<Vec<_>>>()?; - path.segments.last_mut().unwrap().parameters = if - template_args.is_empty() { - None - } else { - Some(P(ast::PathParameters::AngleBracketed( - ast::AngleBracketedParameterData { - lifetimes: vec![], - types: template_args, - bindings: vec![], - } - ))) - } + path.segments.last_mut().unwrap().parameters = + if template_args.is_empty() { + None + } else { + Some(P(ast::PathParameters::AngleBracketed( + ast::AngleBracketedParameterData { + lifetimes: vec![], + types: template_args, + bindings: vec![], + }, + ))) + } } Ok(P(ty)) @@ -2984,10 +3115,11 @@ impl TryToRustTy for TemplateInstantiation { impl TryToRustTy for FunctionSig { type Extra = Item; - fn try_to_rust_ty(&self, - ctx: &BindgenContext, - item: &Item) - -> error::Result<P<ast::Ty>> { + fn try_to_rust_ty( + &self, + ctx: &BindgenContext, + item: &Item, + ) -> error::Result<P<ast::Ty>> { // 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); @@ -3001,8 +3133,12 @@ impl TryToRustTy for FunctionSig { let abi = match self.abi() { Abi::Known(abi) => abi, Abi::Unknown(unknown_abi) => { - panic!("Invalid or unknown abi {:?} for function {:?} {:?}", - unknown_abi, item.canonical_name(ctx), self); + panic!( + "Invalid or unknown abi {:?} for function {:?} {:?}", + unknown_abi, + item.canonical_name(ctx), + self + ); } }; @@ -3024,10 +3160,12 @@ impl TryToRustTy for FunctionSig { impl CodeGenerator for Function { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { debug!("<Function as CodeGenerator>::codegen: item = {:?}", item); debug_assert!(item.is_enabled_for_codegen(ctx)); @@ -3100,8 +3238,12 @@ impl CodeGenerator for Function { let abi = match signature.abi() { Abi::Known(abi) => abi, Abi::Unknown(unknown_abi) => { - panic!("Invalid or unknown abi {:?} for function {:?} ({:?})", - unknown_abi, canonical_name, self); + panic!( + "Invalid or unknown abi {:?} for function {:?} ({:?})", + unknown_abi, + canonical_name, + self + ); } }; @@ -3114,11 +3256,12 @@ impl CodeGenerator for Function { } -fn objc_method_codegen(ctx: &BindgenContext, - method: &ObjCMethod, - class_name: Option<&str>, - prefix: &str) - -> (ast::ImplItem, ast::TraitItem) { +fn objc_method_codegen( + ctx: &BindgenContext, + method: &ObjCMethod, + class_name: Option<&str>, + prefix: &str, +) -> (ast::ImplItem, ast::TraitItem) { let signature = method.signature(); let fn_args = utils::fnsig_arguments(ctx, signature); let fn_ret = utils::fnsig_return_ty(ctx, signature); @@ -3142,7 +3285,8 @@ fn objc_method_codegen(ctx: &BindgenContext, }; // Collect the actual used argument names - let arg_names: Vec<_> = fn_args.iter() + let arg_names: Vec<_> = fn_args + .iter() .map(|ref arg| match arg.pat.node { ast::PatKind::Ident(_, ref spanning, _) => { spanning.node.name.as_str().to_string() @@ -3157,9 +3301,9 @@ fn objc_method_codegen(ctx: &BindgenContext, ctx.rust_ident(&method.format_method_call(&arg_names)); let body = if method.is_class_method() { - let class_name = - class_name.expect("Generating a class method without class name?") - .to_owned(); + let class_name = class_name + .expect("Generating a class method without class name?") + .to_owned(); let expect_msg = format!("Couldn't find {}", class_name); quote_stmt!(ctx.ext_cx(), msg_send![objc::runtime::Class::get($class_name).expect($expect_msg), $methods_and_args]) @@ -3202,10 +3346,12 @@ fn objc_method_codegen(ctx: &BindgenContext, impl CodeGenerator for ObjCInterface { type Extra = Item; - fn codegen<'a>(&self, - ctx: &BindgenContext, - result: &mut CodegenResult<'a>, - item: &Item) { + fn codegen<'a>( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'a>, + item: &Item, + ) { debug_assert!(item.is_enabled_for_codegen(ctx)); let mut impl_items = vec![]; @@ -3218,18 +3364,20 @@ impl CodeGenerator for ObjCInterface { trait_items.push(trait_item) } - let instance_method_names : Vec<_> = self.methods().iter().map( { |m| m.rust_name() } ).collect(); + let instance_method_names: Vec<_> = + self.methods().iter().map({ |m| m.rust_name() }).collect(); for class_method in self.class_methods() { - let ambiquity = instance_method_names.contains(&class_method.rust_name()); - let prefix = if ambiquity { - "class_" - } else { - "" - }; - let (impl_item, trait_item) = - objc_method_codegen(ctx, class_method, Some(self.name()), prefix); + let ambiquity = + instance_method_names.contains(&class_method.rust_name()); + let prefix = if ambiquity { "class_" } else { "" }; + let (impl_item, trait_item) = objc_method_codegen( + ctx, + class_method, + Some(self.name()), + prefix, + ); impl_items.push(impl_item); trait_items.push(trait_item) } @@ -3289,7 +3437,7 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> { } mod utils { - use super::{error, TryToRustTy, ToRustTyOrOpaque}; + use super::{error, ToRustTyOrOpaque, TryToRustTy}; use aster; use ir::context::{BindgenContext, ItemId}; use ir::function::FunctionSig; @@ -3299,35 +3447,36 @@ mod utils { use syntax::ast; use syntax::ptr::P; - pub fn prepend_objc_header(ctx: &BindgenContext, - result: &mut Vec<P<ast::Item>>) { + pub fn prepend_objc_header( + ctx: &BindgenContext, + result: &mut Vec<P<ast::Item>>, + ) { let use_objc = if ctx.options().objc_extern_crate { quote_item!(ctx.ext_cx(), #[macro_use] extern crate objc; - ) - .unwrap() + ).unwrap() } else { quote_item!(ctx.ext_cx(), use objc; - ) - .unwrap() + ).unwrap() }; let id_type = quote_item!(ctx.ext_cx(), #[allow(non_camel_case_types)] pub type id = *mut objc::runtime::Object; - ) - .unwrap(); + ).unwrap(); let items = vec![use_objc, id_type]; let old_items = mem::replace(result, items); result.extend(old_items.into_iter()); } - pub fn prepend_union_types(ctx: &BindgenContext, - result: &mut Vec<P<ast::Item>>) { + pub fn prepend_union_types( + ctx: &BindgenContext, + result: &mut Vec<P<ast::Item>>, + ) { let prefix = ctx.trait_prefix(); // TODO(emilio): The fmt::Debug impl could be way nicer with @@ -3336,8 +3485,7 @@ mod utils { #[repr(C)] pub struct __BindgenUnionField<T>( ::$prefix::marker::PhantomData<T>); - ) - .unwrap(); + ).unwrap(); let union_field_impl = quote_item!(&ctx.ext_cx(), impl<T> __BindgenUnionField<T> { @@ -3356,8 +3504,7 @@ mod utils { ::$prefix::mem::transmute(self) } } - ) - .unwrap(); + ).unwrap(); let union_field_default_impl = quote_item!(&ctx.ext_cx(), impl<T> ::$prefix::default::Default for __BindgenUnionField<T> { @@ -3366,8 +3513,7 @@ mod utils { Self::new() } } - ) - .unwrap(); + ).unwrap(); let union_field_clone_impl = quote_item!(&ctx.ext_cx(), impl<T> ::$prefix::clone::Clone for __BindgenUnionField<T> { @@ -3376,13 +3522,11 @@ mod utils { Self::new() } } - ) - .unwrap(); + ).unwrap(); let union_field_copy_impl = quote_item!(&ctx.ext_cx(), impl<T> ::$prefix::marker::Copy for __BindgenUnionField<T> {} - ) - .unwrap(); + ).unwrap(); let union_field_debug_impl = quote_item!(ctx.ext_cx(), impl<T> ::$prefix::fmt::Debug for __BindgenUnionField<T> { @@ -3391,8 +3535,7 @@ mod utils { fmt.write_str("__BindgenUnionField") } } - ) - .unwrap(); + ).unwrap(); let items = vec![union_field_decl, union_field_impl, @@ -3405,8 +3548,10 @@ mod utils { result.extend(old_items.into_iter()); } - pub fn prepend_incomplete_array_types(ctx: &BindgenContext, - result: &mut Vec<P<ast::Item>>) { + pub fn prepend_incomplete_array_types( + ctx: &BindgenContext, + result: &mut Vec<P<ast::Item>>, + ) { let prefix = ctx.trait_prefix(); let incomplete_array_decl = quote_item!(ctx.ext_cx(), @@ -3414,8 +3559,7 @@ mod utils { #[derive(Default)] pub struct __IncompleteArrayField<T>( ::$prefix::marker::PhantomData<T>); - ) - .unwrap(); + ).unwrap(); let incomplete_array_impl = quote_item!(&ctx.ext_cx(), impl<T> __IncompleteArrayField<T> { @@ -3444,8 +3588,7 @@ mod utils { ::$prefix::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } - ) - .unwrap(); + ).unwrap(); let incomplete_array_debug_impl = quote_item!(ctx.ext_cx(), impl<T> ::$prefix::fmt::Debug for __IncompleteArrayField<T> { @@ -3454,8 +3597,7 @@ mod utils { fmt.write_str("__IncompleteArrayField") } } - ) - .unwrap(); + ).unwrap(); let incomplete_array_clone_impl = quote_item!(&ctx.ext_cx(), impl<T> ::$prefix::clone::Clone for __IncompleteArrayField<T> { @@ -3464,13 +3606,11 @@ mod utils { Self::new() } } - ) - .unwrap(); + ).unwrap(); let incomplete_array_copy_impl = quote_item!(&ctx.ext_cx(), impl<T> ::$prefix::marker::Copy for __IncompleteArrayField<T> {} - ) - .unwrap(); + ).unwrap(); let items = vec![incomplete_array_decl, incomplete_array_impl, @@ -3482,8 +3622,10 @@ mod utils { result.extend(old_items.into_iter()); } - pub fn prepend_complex_type(ctx: &BindgenContext, - result: &mut Vec<P<ast::Item>>) { + pub fn prepend_complex_type( + ctx: &BindgenContext, + result: &mut Vec<P<ast::Item>>, + ) { let complex_type = quote_item!(ctx.ext_cx(), #[derive(PartialEq, Copy, Clone, Hash, Debug, Default)] #[repr(C)] @@ -3491,31 +3633,35 @@ mod utils { pub re: T, pub im: T } - ) - .unwrap(); + ).unwrap(); let items = vec![complex_type]; let old_items = mem::replace(result, items); result.extend(old_items.into_iter()); } - pub fn build_templated_path(item: &Item, - ctx: &BindgenContext, - template_params: Vec<ItemId>) - -> error::Result<P<ast::Ty>> { + pub fn build_templated_path( + item: &Item, + ctx: &BindgenContext, + template_params: Vec<ItemId>, + ) -> error::Result<P<ast::Ty>> { let path = item.namespace_aware_canonical_path(ctx); let builder = aster::AstBuilder::new().ty().path(); - let template_params = template_params.iter() + let template_params = template_params + .iter() .map(|param| param.try_to_rust_ty(ctx, &())) .collect::<error::Result<Vec<_>>>()?; // XXX: I suck at aster. if path.len() == 1 { - return Ok(builder.segment(&path[0]) - .with_tys(template_params) - .build() - .build()); + return Ok( + builder + .segment(&path[0]) + .with_tys(template_params) + .build() + .build(), + ); } let mut builder = builder.id(&path[0]); @@ -3523,7 +3669,8 @@ mod utils { // Take into account the skip(1) builder = if i == path.len() - 2 { // XXX Extra clone courtesy of the borrow checker. - builder.segment(&segment) + builder + .segment(&segment) .with_tys(template_params.clone()) .build() } else { @@ -3539,10 +3686,11 @@ mod utils { quote_ty!(ctx.ext_cx(), $ident) } - pub fn type_from_named(ctx: &BindgenContext, - name: &str, - _inner: ItemId) - -> Option<P<ast::Ty>> { + pub fn type_from_named( + ctx: &BindgenContext, + name: &str, + _inner: ItemId, + ) -> Option<P<ast::Ty>> { // 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 { @@ -3557,23 +3705,23 @@ mod utils { "uintptr_t" | "size_t" => primitive_ty(ctx, "usize"), - "intptr_t" | "ptrdiff_t" | "ssize_t" => { - primitive_ty(ctx, "isize") - } + "intptr_t" | "ptrdiff_t" | "ssize_t" => primitive_ty(ctx, "isize"), _ => return None, }) } - pub fn rust_fndecl_from_signature(ctx: &BindgenContext, - sig: &Item) - -> P<ast::FnDecl> { + pub fn rust_fndecl_from_signature( + ctx: &BindgenContext, + sig: &Item, + ) -> P<ast::FnDecl> { let signature = sig.kind().expect_type().canonical_type(ctx); let signature = match *signature.kind() { TypeKind::Function(ref sig) => sig, _ => panic!("How?"), }; - let decl_ty = signature.try_to_rust_ty(ctx, sig) + let decl_ty = signature + .try_to_rust_ty(ctx, sig) .expect("function signature to Rust type conversion is infallible"); match decl_ty.unwrap().node { ast::TyKind::BareFn(bare_fn) => bare_fn.unwrap().decl, @@ -3581,9 +3729,10 @@ mod utils { } } - pub fn fnsig_return_ty(ctx: &BindgenContext, - sig: &FunctionSig) - -> ast::FunctionRetTy { + pub fn fnsig_return_ty( + ctx: &BindgenContext, + sig: &FunctionSig, + ) -> ast::FunctionRetTy { let return_item = ctx.resolve_item(sig.return_type()); if let TypeKind::Void = *return_item.kind().expect_type().kind() { ast::FunctionRetTy::Default(ctx.span()) @@ -3592,9 +3741,10 @@ mod utils { } } - pub fn fnsig_arguments(ctx: &BindgenContext, - sig: &FunctionSig) - -> Vec<ast::Arg> { + pub fn fnsig_arguments( + ctx: &BindgenContext, + sig: &FunctionSig, + ) -> Vec<ast::Arg> { use super::ToPtr; let mut unnamed_arguments = 0; sig.argument_types().iter().map(|&(ref name, ty)| { |