summaryrefslogtreecommitdiff
path: root/src/codegen/mod.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/codegen/mod.rs')
-rwxr-xr-xsrc/codegen/mod.rs506
1 files changed, 306 insertions, 200 deletions
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index a656c2c1..a4d717d3 100755
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1,32 +1,32 @@
mod helpers;
-use self::helpers::{attributes, BlobTyBuilder};
+use aster;
+use ir::annotations::FieldAccessorKind;
+use ir::comp::{CompInfo, CompKind, Field, Method};
use ir::context::BindgenContext;
-use ir::item::{Item, ItemId, ItemCanonicalName, ItemCanonicalPath};
-use ir::ty::{Type, TypeKind};
-use ir::int::IntKind;
-use ir::module::Module;
-use ir::var::Var;
use ir::enum_ty::Enum;
use ir::function::{Function, FunctionSig};
+use ir::int::IntKind;
+use ir::item::{Item, ItemCanonicalName, ItemCanonicalPath, ItemId};
use ir::item_kind::ItemKind;
-use ir::comp::{CompKind, CompInfo, Field, Method};
use ir::layout::Layout;
-use ir::annotations::FieldAccessorKind;
+use ir::module::Module;
+use ir::ty::{Type, TypeKind};
use ir::type_collector::{ItemSet, TypeCollector};
-
-use std::ops;
+use ir::var::Var;
+use self::helpers::{BlobTyBuilder, attributes};
use std::borrow::Cow;
-use std::mem;
use std::collections::HashSet;
-use std::collections::hash_map::{HashMap, Entry};
+use std::collections::hash_map::{Entry, HashMap};
+use std::mem;
+
+use std::ops;
use syntax::abi::Abi;
use syntax::ast;
use syntax::codemap::{Span, respan};
use syntax::ptr::P;
-use aster;
fn root_import(ctx: &BindgenContext) -> P<ast::Item> {
assert!(ctx.options().enable_cxx_namespaces, "Somebody messed it up");
@@ -39,7 +39,8 @@ struct CodegenResult {
items: Vec<P<ast::Item>>,
saw_union: bool,
items_seen: HashSet<ItemId>,
- /// The set of generated function/var names, needed because in C/C++ is legal to
+ /// The set of generated function/var names, needed because in C/C++ is
+ /// legal to
/// do something like:
///
/// ```c++
@@ -99,7 +100,7 @@ impl CodegenResult {
}
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();
@@ -135,7 +136,7 @@ impl ForeignModBuilder {
inner: ast::ForeignMod {
abi: abi,
items: vec![],
- }
+ },
}
}
@@ -146,7 +147,7 @@ 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
@@ -182,7 +183,7 @@ impl ToPtr for P<ast::Ty> {
ast::Mutability::Immutable
} else {
ast::Mutability::Mutable
- }
+ },
});
P(ast::Ty {
id: ast::DUMMY_NODE_ID,
@@ -217,20 +218,21 @@ impl CodeGenerator for Item {
match *self.kind() {
ItemKind::Module(ref module) => {
- if !ctx.options().enable_cxx_namespaces && self.id() == ctx.root_module() {
+ if !ctx.options().enable_cxx_namespaces &&
+ self.id() == ctx.root_module() {
return;
}
module.codegen(ctx, result, self);
- },
+ }
ItemKind::Function(ref fun) => {
if !ctx.options().ignore_functions {
fun.codegen(ctx, result, self);
}
- },
+ }
ItemKind::Var(ref var) => {
var.codegen(ctx, result, self);
- },
+ }
ItemKind::Type(ref ty) => {
ty.codegen(ctx, result, self);
}
@@ -265,8 +267,10 @@ impl CodeGenerator for Module {
});
let name = item.canonical_name(ctx);
- let item = aster::AstBuilder::new().item().pub_()
- .build_item_kind(name, module);
+ let item = aster::AstBuilder::new()
+ .item()
+ .pub_()
+ .build_item_kind(name, module);
result.push(item);
}
@@ -288,9 +292,13 @@ impl CodeGenerator for Var {
let ty = self.ty().to_rust_ty(ctx);
if let Some(val) = self.val() {
- let const_item = aster::AstBuilder::new().item().pub_()
- .const_(canonical_name)
- .expr().int(val).build(ty);
+ let const_item = aster::AstBuilder::new()
+ .item()
+ .pub_()
+ .const_(canonical_name)
+ .expr()
+ .int(val)
+ .build(ty);
result.push(const_item)
} else {
let mut attrs = vec![];
@@ -310,8 +318,8 @@ impl CodeGenerator for Var {
};
let item = ForeignModBuilder::new(Abi::C)
- .with_foreign_item(item)
- .build(ctx);
+ .with_foreign_item(item)
+ .build(ctx);
result.push(item);
}
}
@@ -368,7 +376,8 @@ impl CodeGenerator for Type {
return;
}
- let mut applicable_template_args = item.applicable_template_args(ctx);
+ let mut applicable_template_args =
+ item.applicable_template_args(ctx);
let inner_rust_type = if item.is_opaque(ctx) {
applicable_template_args.clear();
// Pray if there's no layout.
@@ -394,7 +403,8 @@ impl CodeGenerator for Type {
error!("Item contained `typename`'d template param: {:?}", item);
return;
}
- generics = generics.ty_param_id(template_arg.name().unwrap());
+ generics =
+ generics.ty_param_id(template_arg.name().unwrap());
}
}
@@ -402,8 +412,9 @@ impl CodeGenerator for Type {
result.push(typedef)
}
TypeKind::Enum(ref ei) => ei.codegen(ctx, result, item),
- ref u @ TypeKind::UnresolvedTypeRef(..)
- => unreachable!("Should have been resolved after parsing {:?}!", u),
+ ref u @ TypeKind::UnresolvedTypeRef(..) => {
+ unreachable!("Should have been resolved after parsing {:?}!", u)
+ }
}
}
}
@@ -417,7 +428,10 @@ struct Vtable<'a> {
}
impl<'a> Vtable<'a> {
- fn new(item_id: ItemId, methods: &'a [Method], base_classes: &'a [ItemId]) -> Self {
+ fn new(item_id: ItemId,
+ methods: &'a [Method],
+ base_classes: &'a [ItemId])
+ -> Self {
Vtable {
item_id: item_id,
methods: methods,
@@ -436,10 +450,12 @@ impl<'a> CodeGenerator for Vtable<'a> {
assert_eq!(item.id(), self.item_id);
// For now, generate an empty struct, later we should generate function
// pointers and whatnot.
- let vtable = aster::AstBuilder::new().item().pub_()
- .with_attr(attributes::repr("C"))
- .struct_(self.canonical_name(ctx))
- .build();
+ let vtable = aster::AstBuilder::new()
+ .item()
+ .pub_()
+ .with_attr(attributes::repr("C"))
+ .struct_(self.canonical_name(ctx))
+ .build();
result.push(vtable);
}
}
@@ -475,8 +491,9 @@ impl<'a> Bitfield<'a> {
methods: &mut Vec<ast::ImplItem>) {
use aster::struct_field::StructFieldBuilder;
use std::cmp;
- let mut total_width = self.fields.iter()
- .fold(0u32, |acc, f| acc + f.bitfield().unwrap());
+ let mut total_width = self.fields
+ .iter()
+ .fold(0u32, |acc, f| acc + f.bitfield().unwrap());
if !total_width.is_power_of_two() || total_width < 8 {
total_width = cmp::max(8, total_width.next_power_of_two());
@@ -485,11 +502,14 @@ impl<'a> Bitfield<'a> {
let total_width_in_bytes = total_width as usize / 8;
let bitfield_type =
- BlobTyBuilder::new(Layout::new(total_width_in_bytes, total_width_in_bytes)).build();
+ BlobTyBuilder::new(Layout::new(total_width_in_bytes,
+ total_width_in_bytes))
+ .build();
let field_name = format!("_bitfield_{}", self.index);
let field_ident = ctx.ext_cx().ident_of(&field_name);
- let field = StructFieldBuilder::named(&field_name).pub_()
- .build_ty(bitfield_type.clone());
+ let field = StructFieldBuilder::named(&field_name)
+ .pub_()
+ .build_ty(bitfield_type.clone());
fields.push(field);
@@ -497,19 +517,21 @@ impl<'a> Bitfield<'a> {
for field in self.fields {
let width = field.bitfield().unwrap();
let field_name = field.name()
- .map(ToOwned::to_owned)
- .unwrap_or_else(|| format!("at_offset_{}", offset));
+ .map(ToOwned::to_owned)
+ .unwrap_or_else(|| format!("at_offset_{}", offset));
let field_item = ctx.resolve_item(field.ty());
- let field_ty_layout = field_item.kind().expect_type()
- .layout(ctx)
- .expect("Bitfield without layout? Gah!");
+ let field_ty_layout = field_item.kind()
+ .expect_type()
+ .layout(ctx)
+ .expect("Bitfield without layout? Gah!");
let field_type = field_item.to_rust_ty(ctx);
let int_type = BlobTyBuilder::new(field_ty_layout).build();
let getter_name = ctx.ext_cx().ident_of(&field_name);
- let setter_name = ctx.ext_cx().ident_of(&format!("set_{}", &field_name));
+ let setter_name = ctx.ext_cx()
+ .ident_of(&format!("set_{}", &field_name));
let mask = ((1usize << width) - 1) << offset;
// The transmute is unfortunate, but it's needed for enums in
// bitfields.
@@ -555,7 +577,8 @@ impl CodeGenerator for CompInfo {
// also don't output template specializations, neither total or partial.
//
// TODO: Generate layout tests for template specializations, yay!
- if self.has_non_type_template_params() || self.is_template_specialization() {
+ if self.has_non_type_template_params() ||
+ self.is_template_specialization() {
return;
}
@@ -598,16 +621,21 @@ impl CodeGenerator for CompInfo {
attributes.push(attributes::derives(&derives))
}
- let mut template_args_used = vec![false; applicable_template_args.len()];
+ let mut template_args_used =
+ vec![false; applicable_template_args.len()];
let canonical_name = item.canonical_name(ctx);
let builder = if is_union && ctx.options().unstable_rust {
- aster::AstBuilder::new().item().pub_()
- .with_attrs(attributes)
- .union_(&canonical_name)
+ aster::AstBuilder::new()
+ .item()
+ .pub_()
+ .with_attrs(attributes)
+ .union_(&canonical_name)
} else {
- aster::AstBuilder::new().item().pub_()
- .with_attrs(attributes)
- .struct_(&canonical_name)
+ aster::AstBuilder::new()
+ .item()
+ .pub_()
+ .with_attrs(attributes)
+ .struct_(&canonical_name)
};
// Generate the vtable from the method list if appropriate.
@@ -623,15 +651,15 @@ impl CodeGenerator for CompInfo {
// the parent too.
let mut fields = vec![];
if self.needs_explicit_vtable(ctx) {
- let vtable = Vtable::new(item.id(),
- self.methods(),
- self.base_members());
+ let vtable =
+ Vtable::new(item.id(), self.methods(), self.base_members());
vtable.codegen(ctx, result, item);
let vtable_type = vtable.to_rust_ty(ctx).to_ptr(true, ctx.span());
- let vtable_field = StructFieldBuilder::named("vtable_").pub_()
- .build_ty(vtable_type);
+ let vtable_field = StructFieldBuilder::named("vtable_")
+ .pub_()
+ .build_ty(vtable_type);
fields.push(vtable_field);
}
@@ -663,7 +691,8 @@ impl CodeGenerator for CompInfo {
};
let field = StructFieldBuilder::named(field_name)
- .pub_().build_ty(inner);
+ .pub_()
+ .build_ty(inner);
fields.push(field);
}
if is_union {
@@ -678,11 +707,11 @@ impl CodeGenerator for CompInfo {
let mut bitfield_count = 0;
let struct_fields = self.fields();
let fields_should_be_private = item.annotations()
- .private_fields()
- .unwrap_or(false);
+ .private_fields()
+ .unwrap_or(false);
let struct_accessor_kind = item.annotations()
- .accessor_kind()
- .unwrap_or(FieldAccessorKind::None);
+ .accessor_kind()
+ .unwrap_or(FieldAccessorKind::None);
let mut methods = vec![];
let mut anonymous_field_count = 0;
@@ -695,15 +724,16 @@ impl CodeGenerator for CompInfo {
let field_ty = ctx.resolve_type(field.ty());
// Try to catch a bitfield contination early.
- if let (Some(ref mut bitfield_width), Some(width)) = (current_bitfield_width, field.bitfield()) {
+ if let (Some(ref mut bitfield_width), Some(width)) =
+ (current_bitfield_width, field.bitfield()) {
let layout = current_bitfield_layout.unwrap();
debug!("Testing bitfield continuation {} {} {:?}",
*bitfield_width, width, layout);
- if *bitfield_width + width <= (layout.size * 8) as u32 {
- *bitfield_width += width;
- current_bitfield_fields.push(field);
- continue;
- }
+ if *bitfield_width + width <= (layout.size * 8) as u32 {
+ *bitfield_width += width;
+ current_bitfield_fields.push(field);
+ continue;
+ }
}
// Flush the current bitfield.
@@ -721,7 +751,7 @@ impl CodeGenerator for CompInfo {
if let Some(width) = field.bitfield() {
let layout = field_ty.layout(ctx)
- .expect("Bitfield type without layout?");
+ .expect("Bitfield type without layout?");
current_bitfield_width = Some(width);
current_bitfield_layout = Some(layout);
current_bitfield_fields.push(field);
@@ -756,12 +786,12 @@ impl CodeGenerator for CompInfo {
};
let is_private = field.annotations()
- .private_fields()
- .unwrap_or(fields_should_be_private);
+ .private_fields()
+ .unwrap_or(fields_should_be_private);
let accessor_kind = field.annotations()
- .accessor_kind()
- .unwrap_or(struct_accessor_kind);
+ .accessor_kind()
+ .unwrap_or(struct_accessor_kind);
let mut field = StructFieldBuilder::named(&field_name);
@@ -770,7 +800,7 @@ impl CodeGenerator for CompInfo {
}
let field = field.with_attrs(attrs)
- .build_ty(ty.clone());
+ .build_ty(ty.clone());
fields.push(field);
@@ -830,9 +860,10 @@ impl CodeGenerator for CompInfo {
};
match accessor_methods_impl.unwrap().node {
- ast::ItemKind::Impl(_, _, _, _, _, ref items)
- => methods.extend(items.clone()),
- _ => unreachable!()
+ ast::ItemKind::Impl(_, _, _, _, _, ref items) => {
+ methods.extend(items.clone())
+ }
+ _ => unreachable!(),
}
}
@@ -842,7 +873,8 @@ impl CodeGenerator for CompInfo {
// FIXME: May need to pass current_bitfield_layout too.
if current_bitfield_width.is_some() {
debug_assert!(!current_bitfield_fields.is_empty());
- let bitfield_fields = mem::replace(&mut current_bitfield_fields, vec![]);
+ let bitfield_fields = mem::replace(&mut current_bitfield_fields,
+ vec![]);
bitfield_count += 1;
Bitfield::new(bitfield_count, bitfield_fields)
.codegen_fields(ctx, &mut fields, &mut methods);
@@ -852,8 +884,9 @@ impl CodeGenerator for CompInfo {
if is_union && !ctx.options().unstable_rust {
let layout = layout.expect("Unable to get layout information?");
let ty = BlobTyBuilder::new(layout).build();
- let field = StructFieldBuilder::named("bindgen_union_field").pub_()
- .build_ty(ty);
+ let field = StructFieldBuilder::named("bindgen_union_field")
+ .pub_()
+ .build_ty(ty);
fields.push(field);
}
@@ -868,8 +901,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 => {
@@ -885,8 +920,9 @@ impl CodeGenerator for CompInfo {
// may add for unused template parameters.
if self.is_unsized(ctx) {
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);
}
@@ -918,7 +954,8 @@ impl CodeGenerator for CompInfo {
let generics = generics.build();
let rust_struct = builder.with_generics(generics.clone())
- .with_fields(fields).build();
+ .with_fields(fields)
+ .build();
result.push(rust_struct);
// Generate the inner types and all that stuff.
@@ -957,19 +994,25 @@ impl CodeGenerator for CompInfo {
fn $fn_name() {
assert_eq!($size_of_expr, $size);
assert_eq!($align_of_expr, $align);
- }).unwrap();
+ })
+ .unwrap();
result.push(item);
}
let mut method_names = Default::default();
for method in self.methods() {
- method.codegen_method(ctx, &mut methods, &mut method_names, result, item);
+ method.codegen_method(ctx,
+ &mut methods,
+ &mut method_names,
+ result,
+ item);
}
}
// NB: We can't use to_rust_ty here since for opaque types this tries to
// use the specialization knowledge to generate a blob field.
- let ty_for_impl = aster::AstBuilder::new().ty().path().id(&canonical_name).build();
+ let ty_for_impl =
+ aster::AstBuilder::new().ty().path().id(&canonical_name).build();
if needs_clone_impl {
let impl_ = quote_item!(ctx.ext_cx(),
impl X {
@@ -982,22 +1025,26 @@ impl CodeGenerator for CompInfo {
_ => unreachable!(),
};
- let clone_impl =
- aster::AstBuilder::new().item().impl_()
- .trait_().id("Clone").build()
- .with_generics(generics.clone())
- .with_items(impl_)
- .build_ty(ty_for_impl.clone());
+ let clone_impl = aster::AstBuilder::new()
+ .item()
+ .impl_()
+ .trait_()
+ .id("Clone")
+ .build()
+ .with_generics(generics.clone())
+ .with_items(impl_)
+ .build_ty(ty_for_impl.clone());
result.push(clone_impl);
}
if !methods.is_empty() {
- let methods =
- aster::AstBuilder::new().item().impl_()
- .with_generics(generics)
- .with_items(methods)
- .build_ty(ty_for_impl);
+ let methods = aster::AstBuilder::new()
+ .item()
+ .impl_()
+ .with_generics(generics)
+ .with_items(methods)
+ .build_ty(ty_for_impl);
result.push(methods);
}
}
@@ -1040,7 +1087,7 @@ impl MethodCodegen for Method {
let count = {
let mut count = method_names.entry(name.clone())
- .or_insert(0);
+ .or_insert(0);
*count += 1;
*count - 1
};
@@ -1050,7 +1097,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() {
let mutability = if self.is_const() {
ast::Mutability::Immutable
@@ -1095,16 +1143,19 @@ impl MethodCodegen for Method {
// TODO: We need to keep in sync the argument names, so we should unify
// this with the other loop that decides them.
let mut unnamed_arguments = 0;
- let mut exprs = signature.argument_types().iter().map(|&(ref name, _ty)| {
- let arg_name = match *name {
- Some(ref name) => ctx.rust_mangle(name).into_owned(),
- None => {
- unnamed_arguments += 1;
- format!("arg{}", unnamed_arguments)
- }
- };
- aster::expr::ExprBuilder::new().id(arg_name)
- }).collect::<Vec<_>>();
+ let mut exprs = signature.argument_types()
+ .iter()
+ .map(|&(ref name, _ty)| {
+ let arg_name = match *name {
+ Some(ref name) => ctx.rust_mangle(name).into_owned(),
+ None => {
+ unnamed_arguments += 1;
+ format!("arg{}", unnamed_arguments)
+ }
+ };
+ aster::expr::ExprBuilder::new().id(arg_name)
+ })
+ .collect::<Vec<_>>();
if !self.is_static() {
assert!(!exprs.is_empty());
@@ -1115,10 +1166,11 @@ impl MethodCodegen for Method {
};
};
- let call = aster::expr::ExprBuilder::new().call()
- .id(function_name)
- .with_args(exprs)
- .build();
+ let call = aster::expr::ExprBuilder::new()
+ .call()
+ .id(function_name)
+ .with_args(exprs)
+ .build();
let block = ast::Block {
stmts: vec![
@@ -1164,10 +1216,12 @@ 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!");
IntKind::Int
@@ -1203,8 +1257,12 @@ impl CodeGenerator for Enum {
builder = builder.with_attr(attributes::doc(comment));
}
- 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);
@@ -1213,7 +1271,8 @@ impl CodeGenerator for Enum {
fn add_constant(enum_: &Type,
// Only to avoid recomputing every time.
enum_canonical_name: &str,
- // May be the same as "variant" if it's because the enum
+ // 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,
@@ -1225,11 +1284,15 @@ impl CodeGenerator for Enum {
variant_name.into()
};
- let constant = aster::AstBuilder::new().item().pub_()
- .const_(constant_name)
- .expr().path()
- .ids(&[&*enum_canonical_name, referenced_name])
- .build().build(enum_rust_ty);
+ let constant = aster::AstBuilder::new()
+ .item()
+ .pub_()
+ .const_(constant_name)
+ .expr()
+ .path()
+ .ids(&[&*enum_canonical_name, referenced_name])
+ .build()
+ .build(enum_rust_ty);
result.push(constant);
}
@@ -1245,8 +1308,11 @@ impl CodeGenerator for Enum {
Entry::Occupied(ref entry) => {
let existing_variant_name = entry.get();
let variant_name = ctx.rust_mangle(variant.name());
- add_constant(enum_ty, &name, &*variant_name,
- existing_variant_name, enum_rust_ty.clone(),
+ add_constant(enum_ty,
+ &name,
+ &*variant_name,
+ existing_variant_name,
+ enum_rust_ty.clone(),
result);
}
Entry::Vacant(entry) => {
@@ -1272,7 +1338,8 @@ impl CodeGenerator for Enum {
variant_name.clone()
} else {
if parent_canonical_name.is_none() {
- parent_canonical_name = Some(item.parent_id().canonical_name(ctx));
+ parent_canonical_name = Some(item.parent_id()
+ .canonical_name(ctx));
}
Cow::Owned(
@@ -1280,8 +1347,11 @@ impl CodeGenerator for Enum {
variant_name))
};
- add_constant(enum_ty, &name, &mangled_name,
- &variant_name, enum_rust_ty.clone(),
+ add_constant(enum_ty,
+ &name,
+ &mangled_name,
+ &variant_name,
+ enum_rust_ty.clone(),
result);
}
@@ -1298,7 +1368,10 @@ impl CodeGenerator for Enum {
trait ToRustTy {
type Extra;
- fn to_rust_ty(&self, ctx: &BindgenContext, extra: &Self::Extra) -> P<ast::Ty>;
+ fn to_rust_ty(&self,
+ ctx: &BindgenContext,
+ extra: &Self::Extra)
+ -> P<ast::Ty>;
}
trait ItemToRustTy {
@@ -1336,7 +1409,9 @@ impl ToRustTy for Type {
TypeKind::Void => raw!(c_void),
// TODO: we should do something smart with nullptr, or maybe *const
// c_void is enough?
- TypeKind::NullPtr => quote_ty!(ctx.ext_cx(), *const ::std::os::raw::c_void),
+ TypeKind::NullPtr => {
+ quote_ty!(ctx.ext_cx(), *const ::std::os::raw::c_void)
+ }
TypeKind::Int(ik) => {
match ik {
IntKind::Bool => aster::ty::TyBuilder::new().bool(),
@@ -1355,8 +1430,9 @@ impl ToRustTy for Type {
// FIXME: This doesn't generate the proper alignment, but we
// can't do better right now. We should be able to use
// i128/u128 when they're available.
- IntKind::U128 |
- IntKind::I128 => aster::ty::TyBuilder::new().array(2).u64(),
+ IntKind::U128 | IntKind::I128 => {
+ aster::ty::TyBuilder::new().array(2).u64()
+ }
}
}
TypeKind::Float(fk) => {
@@ -1365,8 +1441,9 @@ impl ToRustTy for Type {
// account?
match fk {
FloatKind::Float => aster::ty::TyBuilder::new().f32(),
- FloatKind::Double |
- FloatKind::LongDouble => aster::ty::TyBuilder::new().f64(),
+ FloatKind::Double | FloatKind::LongDouble => {
+ aster::ty::TyBuilder::new().f64()
+ }
}
}
TypeKind::Function(ref fs) => {
@@ -1407,7 +1484,9 @@ impl ToRustTy for Type {
// Pray if there's no available layout.
let layout = self.layout(ctx).unwrap_or_else(Layout::zero);
BlobTyBuilder::new(layout).build()
- } else if let Some(ty) = utils::type_from_named(ctx, spelling, inner) {
+ } else if let Some(ty) = utils::type_from_named(ctx,
+ spelling,
+ inner) {
ty
} else {
utils::build_templated_path(item, ctx, true)
@@ -1416,22 +1495,22 @@ impl ToRustTy for Type {
TypeKind::Comp(ref info) => {
if item.is_opaque(ctx) || info.has_non_type_template_params() {
return match self.layout(ctx) {
- Some(layout) => {
- BlobTyBuilder::new(layout).build()
- }
+ Some(layout) => BlobTyBuilder::new(layout).build(),
None => {
warn!("Couldn't compute layout for a type with non \
type template params or opaque, expect dragons!");
aster::AstBuilder::new().ty().unit()
}
- }
+ };
}
utils::build_templated_path(item, ctx, false)
}
TypeKind::BlockPointer => {
let void = raw!(c_void);
- void.to_ptr(/* is_const = */ false, ctx.span())
+ void.to_ptr(/* is_const = */
+ false,
+ ctx.span())
}
TypeKind::Pointer(inner) |
TypeKind::Reference(inner) => {
@@ -1444,7 +1523,8 @@ impl ToRustTy for Type {
if inner_ty.canonical_type(ctx).is_function() {
ty
} else {
- let is_const = self.is_const() || inner.expect_type().is_const();
+ let is_const = self.is_const() ||
+ inner.expect_type().is_const();
ty.to_ptr(is_const, ctx.span())
}
}
@@ -1453,8 +1533,9 @@ impl ToRustTy for Type {
let ident = ctx.rust_ident(&name);
quote_ty!(ctx.ext_cx(), $ident)
}
- ref u @ TypeKind::UnresolvedTypeRef(..)
- => unreachable!("Should have been resolved after parsing {:?}!", u),
+ ref u @ TypeKind::UnresolvedTypeRef(..) => {
+ unreachable!("Should have been resolved after parsing {:?}!", u)
+ }
}
}
}
@@ -1465,11 +1546,12 @@ impl ToRustTy for FunctionSig {
fn to_rust_ty(&self, ctx: &BindgenContext, _item: &Item) -> P<ast::Ty> {
// TODO: we might want to consider ignoring the reference return value.
let return_item = ctx.resolve_item(self.return_type());
- let ret = if let TypeKind::Void = *return_item.kind().expect_type().kind() {
- ast::FunctionRetTy::Default(ctx.span())
- } else {
- ast::FunctionRetTy::Ty(return_item.to_rust_ty(ctx))
- };
+ let ret =
+ if let TypeKind::Void = *return_item.kind().expect_type().kind() {
+ ast::FunctionRetTy::Default(ctx.span())
+ } else {
+ ast::FunctionRetTy::Ty(return_item.to_rust_ty(ctx))
+ };
let mut unnamed_arguments = 0;
let arguments = self.argument_types().iter().map(|&(ref name, ty)| {
@@ -1566,15 +1648,14 @@ impl CodeGenerator for Function {
let foreign_item_kind =
ast::ForeignItemKind::Fn(fndecl, ast::Generics::default());
- let foreign_item =
- ast::ForeignItem {
- ident: ctx.rust_ident_raw(&canonical_name),
- attrs: attributes,
- node: foreign_item_kind,
- id: ast::DUMMY_NODE_ID,
- span: ctx.span(),
- vis: ast::Visibility::Public,
- };
+ let foreign_item = ast::ForeignItem {
+ ident: ctx.rust_ident_raw(&canonical_name),
+ attrs: attributes,
+ node: foreign_item_kind,
+ id: ast::DUMMY_NODE_ID,
+ span: ctx.span(),
+ vis: ast::Visibility::Public,
+ };
let item = ForeignModBuilder::new(signature.abi())
.with_foreign_item(foreign_item)
@@ -1596,7 +1677,8 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
context.options().whitelisted_functions.is_empty() &&
context.options().whitelisted_vars.is_empty() {
for (_item_id, item) in context.items() {
- // Non-toplevel item parents are the responsible one for generating
+ // Non-toplevel item parents are the responsible one for
+ // generating
// them.
if item.is_toplevel(context) {
item.codegen(context, &mut result, &());
@@ -1629,17 +1711,24 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
if let TypeKind::Enum(ref enum_) = *ty.kind() {
if ty.name().is_none() {
if enum_.variants().iter().any(|variant| {
- context.options().whitelisted_vars.matches(&variant.name())
+ context.options()
+ .whitelisted_vars
+ .matches(&variant.name())
}) {
- item.collect_types(context, &mut items, &());
+ item.collect_types(context,
+ &mut items,
+ &());
}
}
}
}
ItemKind::Function(ref fun) => {
- if context.options().whitelisted_functions.matches(&name) {
+ if context.options()
+ .whitelisted_functions
+ .matches(&name) {
items.insert(item.id());
- fun.signature().collect_types(context, &mut items, &());
+ fun.signature()
+ .collect_types(context, &mut items, &());
}
}
ItemKind::Var(ref var) => {
@@ -1652,7 +1741,10 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
}
}
- fn contains_parent(ctx: &BindgenContext, types: &ItemSet, id: ItemId) -> bool {
+ fn contains_parent(ctx: &BindgenContext,
+ types: &ItemSet,
+ id: ItemId)
+ -> bool {
let item = ctx.resolve_item(id);
let mut last = id;
let mut current = item.parent_id();
@@ -1670,7 +1762,8 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
for item_id in items.iter() {
let item = context.resolve_item(*item_id);
- if item.is_toplevel(context) || !contains_parent(context, &items, *item_id) {
+ if item.is_toplevel(context) ||
+ !contains_parent(context, &items, *item_id) {
item.codegen(context, &mut result, &());
}
}
@@ -1685,21 +1778,23 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
}
mod utils {
+ use aster;
use ir::context::BindgenContext;
use ir::item::{Item, ItemCanonicalPath, ItemId};
use ir::ty::TypeKind;
- use syntax::ast;
- use syntax::ptr::P;
use std::mem;
use super::ItemToRustTy;
- use aster;
+ use syntax::ast;
+ use syntax::ptr::P;
- 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 union_field_decl = quote_item!(ctx.ext_cx(),
#[derive(Debug)]
#[repr(C)]
pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
- ).unwrap();
+ )
+ .unwrap();
let union_field_impl = quote_item!(&ctx.ext_cx(),
impl<T> __BindgenUnionField<T> {
@@ -1718,7 +1813,8 @@ mod utils {
::std::mem::transmute(self)
}
}
- ).unwrap();
+ )
+ .unwrap();
let union_field_default_impl = quote_item!(&ctx.ext_cx(),
impl<T> ::std::default::Default for __BindgenUnionField<T> {
@@ -1727,7 +1823,8 @@ mod utils {
Self::new()
}
}
- ).unwrap();
+ )
+ .unwrap();
let union_field_clone_impl = quote_item!(&ctx.ext_cx(),
impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
@@ -1736,11 +1833,13 @@ mod utils {
Self::new()
}
}
- ).unwrap();
+ )
+ .unwrap();
let union_field_copy_impl = quote_item!(&ctx.ext_cx(),
impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
- ).unwrap();
+ )
+ .unwrap();
let items = vec![
union_field_decl, union_field_impl,
@@ -1754,26 +1853,32 @@ mod utils {
}
- pub fn build_templated_path(item: &Item, ctx: &BindgenContext, only_named: bool) -> P<ast::Ty> {
+ pub fn build_templated_path(item: &Item,
+ ctx: &BindgenContext,
+ only_named: bool)
+ -> P<ast::Ty> {
let path = item.canonical_path(ctx);
let builder = aster::AstBuilder::new().ty().path();
let template_args = if only_named {
- item.applicable_template_args(ctx).iter().filter(|arg| {
- ctx.resolve_type(**arg).is_named()
- }).map(|arg| {
- arg.to_rust_ty(ctx)
- }).collect::<Vec<_>>()
+ item.applicable_template_args(ctx)
+ .iter()
+ .filter(|arg| ctx.resolve_type(**arg).is_named())
+ .map(|arg| arg.to_rust_ty(ctx))
+ .collect::<Vec<_>>()
} else {
- item.applicable_template_args(ctx).iter().map(|arg| {
- arg.to_rust_ty(ctx)
- }).collect::<Vec<_>>()
+ item.applicable_template_args(ctx)
+ .iter()
+ .map(|arg| arg.to_rust_ty(ctx))
+ .collect::<Vec<_>>()
};
// XXX: I suck at aster.
if path.len() == 1 {
return builder.segment(&path[0])
- .with_tys(template_args).build().build();
+ .with_tys(template_args)
+ .build()
+ .build();
}
let mut builder = builder.id(&path[0]);
@@ -1782,7 +1887,8 @@ mod utils {
builder = if i == path.len() - 2 {
// XXX Extra clone courtesy of the borrow checker.
builder.segment(&segment)
- .with_tys(template_args.clone()).build()
+ .with_tys(template_args.clone())
+ .build()
} else {
builder.segment(&segment).build()
}
@@ -1798,7 +1904,8 @@ mod utils {
pub fn type_from_named(ctx: &BindgenContext,
name: &str,
- _inner: ItemId) -> Option<P<ast::Ty>> {
+ _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?
macro_rules! ty {
@@ -1816,17 +1923,16 @@ mod utils {
"int64_t" => ty!(i64),
"uint64_t" => ty!(u64),
- "uintptr_t" |
- "size_t" => ty!(usize),
+ "uintptr_t" | "size_t" => ty!(usize),
- "intptr_t" |
- "ptrdiff_t" |
- "ssize_t" => ty!(isize),
+ "intptr_t" | "ptrdiff_t" | "ssize_t" => ty!(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> {
use codegen::ToRustTy;
let signature = sig.kind().expect_type();
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-05 00:16:14 +0000