Multiple cleanups.

Author: emilio

src/bin/bindgen.rs

@@ -7,25 +7,12 @@ extern crate env_logger;
 extern crate log;
 extern crate clang_sys;
 
-use bindgen::{Bindings, BindgenOptions, LinkType, Logger};
+use bindgen::{Bindings, BindgenOptions, LinkType};
 use std::io;
 use std::path;
 use std::env;
 use std::default::Default;
 use std::fs;
-use std::process::exit;
-
-struct StdLogger;
-
-impl Logger for StdLogger {
-    fn error(&self, msg: &str) {
-        println!("{}", msg);
-    }
-
-    fn warn(&self, msg: &str) {
-        println!("{}", msg);
-    }
-}
 
 enum ParseResult {
     CmdUsage,
@@ -255,17 +242,10 @@ pub fn main() {
         ParseResult::ParseErr(e) => panic!(e),
         ParseResult::CmdUsage => print_usage(bin),
         ParseResult::ParseOk(options, out) => {
-            let logger = StdLogger;
-            match Bindings::generate(&options, Some(&logger as &Logger), None) {
-                Ok(bindings) => match bindings.write(out) {
-                    Ok(()) => (),
-                    Err(e) => {
-                        logger.error(&format!("Unable to write bindings to file. {}", e));
-                        exit(-1);
-                    }
-                },
-                Err(()) => exit(-1)
-            }
+            let bindings = Bindings::generate(&options, None)
+                                .expect("Failed to generate bindings!");
+
+            bindings.write(out).expect("Unable to write bindings!");
         }
     }
 }

src/codegen/mod.rs

@@ -14,17 +14,8 @@ use std::collections::hash_map::{HashMap, Entry};
 
 use syntax::abi::Abi;
 use syntax::ast;
-use syntax::codemap::{Span, respan, ExpnInfo, NameAndSpan, MacroBang};
-use syntax::ext::base;
-use syntax::ext::build::AstBuilder;
-use syntax::ext::expand::ExpansionConfig;
-use syntax::ext::quote::rt::ToTokens;
-use syntax::feature_gate::Features;
-use syntax::parse;
-use syntax::parse::token::{InternedString, intern};
-use syntax::attr::mk_attr_id;
+use syntax::codemap::{Span, respan};
 use syntax::ptr::P;
-use syntax::print::pprust::tts_to_string;
 use aster;
 
 macro_rules! repr {
@@ -96,6 +87,7 @@ impl ForeignModBuilder {
         self
     }
 
+    #[allow(dead_code)]
     fn with_foreign_items<I>(mut self, items: I) -> Self
         where I: IntoIterator<Item=ast::ForeignItem>
     {
@@ -252,7 +244,7 @@ impl ItemCanonicalName for Item {
             ItemKind::Var(ref var) => {
                 var.name().to_owned()
             }
-            ItemKind::Module(ref module) => unimplemented!(), // TODO
+            ItemKind::Module(ref _module) => unimplemented!(), // TODO
         };
 
         if self.is_toplevel(ctx) {
@@ -311,7 +303,6 @@ impl CodeGenerator for Var {
         let ty = self.ty().to_rust_ty(ctx);
 
         if let Some(val) = self.val() {
-            let val = self.val().unwrap();
             let const_item = aster::AstBuilder::new().item().pub_().const_(name)
                                                 .expr().int(val).build(ty);
             result.push(const_item)
@@ -429,7 +420,7 @@ impl<'a> CodeGenerator for Vtable<'a> {
 }
 
 impl<'a> ItemCanonicalName for Vtable<'a> {
-    fn canonical_name(&self, ctx: &BindgenContext) -> String {
+    fn canonical_name(&self, _ctx: &BindgenContext) -> String {
         format!("bindgen_vtable_{}", self.item_id)
     }
 }
@@ -455,10 +446,8 @@ impl CodeGenerator for CompInfo {
         attributes.push(repr!("C"));
 
         let mut template_args_used = vec![false; self.template_args().len()];
-        let is_union = self.kind() == CompKind::Union;
-
         let canonical_name = item.canonical_name(ctx);
-        let mut builder = aster::AstBuilder::new().item().pub_()
+        let builder = aster::AstBuilder::new().item().pub_()
                                 .with_attrs(attributes)
                                 .struct_(&canonical_name);
 
@@ -796,7 +785,6 @@ impl ToRustTy for Type {
                 }
 
                 let name = item.canonical_name(ctx);
-                let ident = ctx.rust_ident(&name);
                 aster::AstBuilder::new().ty().path()
                     .segment(&name)
                     .with_tys(info.template_args().iter().map(|arg| {
@@ -819,7 +807,7 @@ impl ToRustTy for Type {
 impl ToRustTy for FunctionSig {
     type Extra = Item;
 
-    fn to_rust_ty(&self, ctx: &BindgenContext, item: &Item) -> P<ast::Ty> {
+    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() {
@@ -944,7 +932,7 @@ impl CodeGenerator for Function {
 pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
     context.gen(|context| {
         let mut result = CodegenResult::new();
-        for (item_id, item) in context.items() {
+        for (_item_id, item) in context.items() {
             // Non-toplevel item parents are the responsible one for generating
             // them.
             if item.is_toplevel(context) {
@@ -967,7 +955,6 @@ mod utils {
     use std::mem;
 
     pub fn prepend_union_types(ctx: &BindgenContext, result: &mut Vec<P<ast::Item>>) {
-        use std::mem;
         let union_field_decl = quote_item!(ctx.ext_cx(),
             #[derive(Copy, Debug)]
             #[repr(C)]

src/gen.rs

@@ -297,9 +297,6 @@ pub fn gen_mods(links: &[(String, LinkType)],
                 options: BindgenOptions,
                 span: Span) -> Vec<P<ast::Item>> {
     // Create a dummy ExtCtxt. We only need this for string interning and that uses TLS.
-    let mut features = Features::new();
-    features.quote = true;
-
     let cfg = ExpansionConfig::default("xxx".to_owned());
     let sess = parse::ParseSess::new();
     let mut loader = base::DummyMacroLoader;

src/ir/comp.rs

@@ -5,9 +5,8 @@ use super::layout::Layout;
 use super::item::{Item, ItemId};
 use super::ty::Type;
 use std::cell::Cell;
-use parse::{ClangItemParser, ClangSubItemParser, ParseError};
+use parse::{ClangItemParser, ParseError};
 use clang;
-use clangll::Enum_CXCursorKind;
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum CompKind {
@@ -61,6 +60,8 @@ pub struct Field {
     ty: ItemId,
     /// The doc comment on the field if any.
     comment: Option<String>,
+    /// Annotations for this field, or the default.
+    annotations: Annotations,
     /// If this field is a bitfield, and how many bits does it contain if it is.
     bitfield: Option<u32>,
     /// If the C++ field is marked as `mutable`
@@ -78,6 +79,7 @@ impl Field {
             name: name,
             ty: ty,
             comment: comment,
+            annotations: annotations.unwrap_or_default(),
             bitfield: bitfield,
             mutable: mutable,
         }

src/ir/context.rs

@@ -8,7 +8,6 @@ use std::borrow::{Cow, Borrow};
 use std::collections::btree_map::{self, BTreeMap};
 use std::collections::{HashSet, HashMap};
 use std::fmt;
-use syntax;
 use syntax::ast::Ident;
 use syntax::codemap::{DUMMY_SP, Span};
 use syntax::ext::base::ExtCtxt;
@@ -189,10 +188,9 @@ impl<'ctx> BindgenContext<'ctx> {
     pub fn gen<F, Out>(&mut self, cb: F) -> Out
         where F: FnOnce(&Self) -> Out
     {
-        use syntax::codemap::{Span, respan, ExpnInfo, NameAndSpan, MacroBang};
         use syntax::ext::expand::ExpansionConfig;
+        use syntax::codemap::{ExpnInfo, MacroBang, NameAndSpan};
         use syntax::ext::base;
-        use syntax::ext;
         use syntax::parse;
         use std::mem;
 
@@ -236,7 +234,7 @@ impl<'ctx> BindgenContext<'ctx> {
     }
 
     fn build_root_module() -> Item {
-        let module = Module::new(None, None);
+        let module = Module::new(None);
         let id = ItemId::next();
         Item::new(id, None, None, id, ItemKind::Module(module))
     }

src/ir/enum_ty.rs

@@ -1,4 +1,3 @@
-use super::int::IntKind;
 use super::item::{Item, ItemId};
 use super::ty::TypeKind;
 use super::context::BindgenContext;

src/ir/item.rs

@@ -110,9 +110,7 @@ impl ClangItemParser for Item {
              context: &mut BindgenContext) -> Result<ItemId, ParseError> {
         use ir::function::Function;
         use ir::module::Module;
-        use ir::ty::Type;
         use ir::var::Var;
-        use clangll::CXCursor_Namespace;
 
         if !cursor.is_valid() {
             return Err(ParseError::Continue);
@@ -234,7 +232,7 @@ impl ClangItemParser for Item {
             context.currently_parsed_types.push((declaration_to_look_for, id));
         }
 
-        let mut result = Type::from_clang_ty(id, ty, location, parent_id, context);
+        let result = Type::from_clang_ty(id, ty, location, parent_id, context);
         let ret = match result {
             Ok(ParseResult::AlreadyResolved(ty)) => Ok(ty),
             Ok(ParseResult::New(item, declaration)) => {
@@ -260,7 +258,7 @@ impl ClangItemParser for Item {
                         assert_eq!(popped_decl, declaration_to_look_for);
                     }
 
-                    location.visit(|cur, other| {
+                    location.visit(|cur, _other| {
                         use clangll::*;
                         result = Item::from_ty(ty, Some(*cur), parent_id, context);
                         match result {

src/ir/module.rs

@@ -9,32 +9,25 @@ pub struct Module {
     /// The name of the module, or none if it's the root or an anonymous
     /// namespace.
     name: Option<String>,
-    /// The parent module of this.
-    parent_id: Option<ItemId>,
     /// The children of this module, just here for convenience.
     children_ids: Vec<ItemId>,
 }
 
 impl Module {
-    pub fn new(name: Option<String>, parent_id: Option<ItemId>) -> Self {
+    pub fn new(name: Option<String>) -> Self {
         Module {
             name: name,
-            parent_id: None,
             children_ids: vec![],
         }
     }
 
     pub fn name(&self) -> Option<&str> {
         self.name.as_ref().map(|s| &**s)
     }
-
-    pub fn parent(&self) -> Option<ItemId> {
-        self.parent_id
-    }
 }
 
 impl ClangSubItemParser for Module {
-    fn parse(cursor: clang::Cursor, ctx: &mut BindgenContext) -> Result<ParseResult<Self>, ParseError> {
+    fn parse(cursor: clang::Cursor, _ctx: &mut BindgenContext) -> Result<ParseResult<Self>, ParseError> {
         use clangll::*;
         match cursor.kind() {
             CXCursor_Namespace => {

src/ir/ty.rs

@@ -6,7 +6,7 @@ use super::int::IntKind;
 use super::layout::Layout;
 use super::context::BindgenContext;
 use super::context::TypeResolver;
-use parse::{ClangItemParser, ClangSubItemParser, ParseResult, ParseError};
+use parse::{ClangItemParser, ParseResult, ParseError};
 use clang::{self, Cursor};
 
 #[derive(Debug)]
@@ -263,7 +263,6 @@ impl Type {
         }
 
         let layout = ty.fallible_layout().ok();
-        let is_const = ty.is_const();
         let cursor = ty.declaration();
         let mut name = cursor.spelling();
 
@@ -361,7 +360,7 @@ impl Type {
                 TypeKind::Function(signature)
             }
             CXType_Typedef  => {
-                let mut inner = cursor.typedef_type();
+                let inner = cursor.typedef_type();
                 let inner = Item::from_ty(&inner, location, parent_id, ctx)
                                 .expect("Not able to resolve array element?");
                 TypeKind::Alias(ty.spelling(), inner)
@@ -383,7 +382,8 @@ impl Type {
             }
             #[cfg(not(feature="llvm_stable"))]
             CXType_Elaborated => {
-                return Self::from_clang_ty(potential_id, &ty.named(), ctx);
+                return Self::from_clang_ty(potential_id, &ty.named(),
+                                           location, parent_id, ctx);
             }
             _ => {
                 warn!("unsupported type {:?}", ty);