squash! Dead code and imports cleanup

Author: emilio

src/codegen/mod.rs

@@ -4,7 +4,7 @@ use ir::ty::{Type, TypeKind};
 use ir::int::IntKind;
 use ir::module::Module;
 use ir::var::Var;
-use ir::enum_ty::{Enum, EnumVariant};
+use ir::enum_ty::Enum;
 use ir::function::{Function, FunctionSig};
 use ir::item_kind::ItemKind;
 use ir::comp::{CompKind, CompInfo, Field, Method};
@@ -474,7 +474,9 @@ impl CodeGenerator for Type {
 
 struct Vtable<'a> {
     item_id: ItemId,
+    #[allow(dead_code)]
     methods: &'a [Method],
+    #[allow(dead_code)]
     base_classes: &'a [ItemId],
 }
 
@@ -519,15 +521,13 @@ impl<'a> ItemToRustTy for Vtable<'a> {
 }
 
 struct Bitfield<'a> {
-    item: &'a Item,
     index: usize,
     fields: Vec<&'a Field>,
 }
 
 impl<'a> Bitfield<'a> {
-    fn new(item: &'a Item, index: usize, fields: Vec<&'a Field>) -> Self {
+    fn new(index: usize, fields: Vec<&'a Field>) -> Self {
         Bitfield {
-            item: item,
             index: index,
             fields: fields,
         }
@@ -777,7 +777,7 @@ impl CodeGenerator for CompInfo {
                 let bitfield_fields =
                     mem::replace(&mut current_bitfield_fields, vec![]);
                 bitfield_count += 1;
-                Bitfield::new(item, bitfield_count, bitfield_fields)
+                Bitfield::new(bitfield_count, bitfield_fields)
                     .codegen_fields(ctx, &mut fields, &mut methods);
                 current_bitfield_width = None;
                 current_bitfield_layout = None;
@@ -908,7 +908,7 @@ impl CodeGenerator for CompInfo {
             debug_assert!(!current_bitfield_fields.is_empty());
             let bitfield_fields = mem::replace(&mut current_bitfield_fields, vec![]);
             bitfield_count += 1;
-            Bitfield::new(item, bitfield_count, bitfield_fields)
+            Bitfield::new(bitfield_count, bitfield_fields)
                 .codegen_fields(ctx, &mut fields, &mut methods);
         }
         debug_assert!(current_bitfield_fields.is_empty());
@@ -1082,7 +1082,7 @@ impl MethodCodegen for Method {
                       methods: &mut Vec<ast::ImplItem>,
                       method_names: &mut HashMap<String, usize>,
                       result: &mut CodegenResult,
-                      parent: &Item) {
+                      _parent: &Item) {
         if ctx.options().ignore_methods {
             return;
         }
@@ -1701,7 +1701,7 @@ impl TypeCollector for FunctionSig {
     fn collect_types(&self,
                      context: &BindgenContext,
                      types: &mut ItemSet,
-                     item: &Item) {
+                     _item: &Item) {
         self.return_type().collect_types(context, types, &());
 
         for &(_, ty) in self.argument_types() {

src/ir/enum_ty.rs

@@ -56,7 +56,7 @@ impl Enum {
             None => true,
         };
 
-        declaration.visit(|cursor, other| {
+        declaration.visit(|cursor, _| {
             if cursor.kind() == CXCursor_EnumConstantDecl {
                 let name = cursor.spelling();
                 let comment = cursor.raw_comment();

src/ir/function.rs

@@ -74,12 +74,11 @@ fn get_abi(cc: Enum_CXCallingConv) -> abi::Abi {
     }
 }
 
-pub fn cursor_mangling(cursor: &clang::Cursor, ctx: &BindgenContext) -> Option<String> {
+pub fn cursor_mangling(cursor: &clang::Cursor) -> Option<String> {
     let mut mangling = cursor.mangling();
 
     // Try to undo backend linkage munging (prepended _, generally)
     if cfg!(target_os = "macos") {
-       // || (cfg!(target_os = "windows") && !ctx.options.msvc_mangling)
         mangling.remove(0);
     }
 
@@ -208,7 +207,7 @@ impl ClangSubItemParser for Function {
         let name = cursor.spelling();
         assert!(!name.is_empty(), "Empty function name?");
 
-        let mut mangled_name = cursor_mangling(&cursor, context);
+        let mut mangled_name = cursor_mangling(&cursor);
         if mangled_name.as_ref() == Some(&name) {
             mangled_name = None;
         }

src/ir/item.rs

@@ -436,7 +436,6 @@ impl ClangItemParser for Item {
                       location: Option<clang::Cursor>,
                       parent_id: Option<ItemId>,
                       context: &mut BindgenContext) -> ItemId {
-        use clangll::*;
         debug!("from_ty_or_ref: {:?}, {:?}, {:?}", ty, location, parent_id);
 
         if context.collected_typerefs() {

src/ir/module.rs

@@ -1,7 +1,7 @@
 use super::context::BindgenContext;
-use super::item::{ItemId, Item};
+use super::item::ItemId;
 use clang;
-use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult};
+use parse::{ClangSubItemParser, ParseError, ParseResult};
 use parse_one;
 
 /// A module, as in, a C++ namespace.

src/ir/var.rs

@@ -123,7 +123,7 @@ impl ClangSubItemParser for Var {
                     });
                 }
 
-                let mangling = cursor_mangling(&cursor, context);
+                let mangling = cursor_mangling(&cursor);
 
                 let var = Var::new(name, mangling, ty, value, is_const);
                 Ok(ParseResult::New(var, Some(cursor)))