Merge pull request #1473 from emilio/hash

emilio · web-flow · commit 1104631a1426 · 2018-12-29T14:48:48.000+01:00
Some perf tweaks
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -54,6 +54,7 @@ peeking_take_while = "0.1.2"
 quote = { version = "0.6", default-features = false }
 regex = "1.0"
 which = "2.0"
+hashbrown = "0.1"
 # New validation in 0.3.6 breaks bindgen-integration:
 # https://github.com/alexcrichton/proc-macro2/commit/489c642.
 proc-macro2 = { version = "0.4", default-features = false }
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
@@ -43,12 +43,12 @@ use proc_macro2::{self, Ident, Span};
 use std;
 use std::borrow::Cow;
 use std::cell::Cell;
-use std::collections::{HashSet, VecDeque};
-use std::collections::hash_map::{Entry, HashMap};
+use std::collections::VecDeque;
 use std::fmt::Write;
 use std::iter;
 use std::ops;
 use std::str::FromStr;
+use {HashMap, HashSet, Entry};
 
 // Name of type defined in constified enum module
 pub static CONSTIFIED_ENUM_MODULE_REPR_NAME: &'static str = "Type";
@@ -2638,7 +2638,7 @@ impl CodeGenerator for Enum {
         );
 
         // A map where we keep a value -> variant relation.
-        let mut seen_values = HashMap::<_, Ident>::new();
+        let mut seen_values = HashMap::<_, Ident>::default();
         let enum_rust_ty = item.to_rust_ty_or_opaque(ctx, &());
         let is_toplevel = item.is_toplevel(ctx);
 
@@ -3546,11 +3546,12 @@ pub(crate) fn codegen(context: BindgenContext) -> (Vec<proc_macro2::TokenStream>
 
         debug!("codegen: {:?}", context.options());
 
-        let codegen_items = context.codegen_items();
         if context.options().emit_ir {
-            for &id in codegen_items {
-                let item = context.resolve_item(id);
-                println!("ir: {:?} = {:#?}", id, item);
+            let codegen_items = context.codegen_items();
+            for (id, item) in context.items() {
+                if codegen_items.contains(&id) {
+                    println!("ir: {:?} = {:#?}", id, item);
+                }
             }
         }
 
diff --git a/src/ir/analysis/derive_copy.rs b/src/ir/analysis/derive_copy.rs
@@ -11,8 +11,7 @@ use ir::template::TemplateParameters;
 use ir::traversal::EdgeKind;
 use ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
 use ir::ty::TypeKind;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use {HashMap, HashSet};
 
 /// An analysis that finds for each IR item whether copy cannot be derived.
 ///
@@ -103,7 +102,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveCopy<'ctx> {
     type Output = HashSet<ItemId>;
 
     fn new(ctx: &'ctx BindgenContext) -> CannotDeriveCopy<'ctx> {
-        let cannot_derive_copy = HashSet::new();
+        let cannot_derive_copy = HashSet::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         CannotDeriveCopy {
diff --git a/src/ir/analysis/derive_debug.rs b/src/ir/analysis/derive_debug.rs
@@ -10,8 +10,7 @@ use ir::item::IsOpaque;
 use ir::traversal::EdgeKind;
 use ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
 use ir::ty::TypeKind;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use {HashMap, HashSet};
 
 /// An analysis that finds for each IR item whether debug cannot be derived.
 ///
@@ -104,7 +103,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveDebug<'ctx> {
     type Output = HashSet<ItemId>;
 
     fn new(ctx: &'ctx BindgenContext) -> CannotDeriveDebug<'ctx> {
-        let cannot_derive_debug = HashSet::new();
+        let cannot_derive_debug = HashSet::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         CannotDeriveDebug {
diff --git a/src/ir/analysis/derive_default.rs b/src/ir/analysis/derive_default.rs
@@ -12,8 +12,7 @@ use ir::traversal::EdgeKind;
 use ir::traversal::Trace;
 use ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
 use ir::ty::TypeKind;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use {HashMap, HashSet};
 
 /// An analysis that finds for each IR item whether default cannot be derived.
 ///
@@ -99,8 +98,8 @@ impl<'ctx> MonotoneFramework for CannotDeriveDefault<'ctx> {
     type Output = HashSet<ItemId>;
 
     fn new(ctx: &'ctx BindgenContext) -> CannotDeriveDefault<'ctx> {
-        let mut dependencies = HashMap::new();
-        let cannot_derive_default = HashSet::new();
+        let mut dependencies = HashMap::default();
+        let cannot_derive_default = HashSet::default();
 
         let whitelisted_items: HashSet<_> =
             ctx.whitelisted_items().iter().cloned().collect();
diff --git a/src/ir/analysis/derive_hash.rs b/src/ir/analysis/derive_hash.rs
@@ -10,8 +10,7 @@ use ir::item::IsOpaque;
 use ir::traversal::EdgeKind;
 use ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
 use ir::ty::TypeKind;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use {HashMap, HashSet};
 
 /// An analysis that finds for each IR item whether hash cannot be derived.
 ///
@@ -96,7 +95,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
     type Output = HashSet<ItemId>;
 
     fn new(ctx: &'ctx BindgenContext) -> CannotDeriveHash<'ctx> {
-        let cannot_derive_hash = HashSet::new();
+        let cannot_derive_hash = HashSet::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         CannotDeriveHash {
diff --git a/src/ir/analysis/derive_partialeq_or_partialord.rs b/src/ir/analysis/derive_partialeq_or_partialord.rs
@@ -9,8 +9,7 @@ use ir::item::{Item, IsOpaque};
 use ir::traversal::{EdgeKind, Trace};
 use ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
 use ir::ty::{TypeKind, Type};
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
+use {HashMap, Entry};
 
 /// An analysis that finds for each IR item whether `PartialEq`/`PartialOrd`
 /// cannot be derived.
@@ -326,7 +325,7 @@ impl<'ctx> MonotoneFramework for CannotDerivePartialEqOrPartialOrd<'ctx> {
     fn new(
         ctx: &'ctx BindgenContext,
     ) -> CannotDerivePartialEqOrPartialOrd<'ctx> {
-        let can_derive_partialeq_or_partialord = HashMap::new();
+        let can_derive_partialeq_or_partialord = HashMap::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         CannotDerivePartialEqOrPartialOrd {
diff --git a/src/ir/analysis/has_destructor.rs b/src/ir/analysis/has_destructor.rs
@@ -5,8 +5,7 @@ use ir::context::{BindgenContext, ItemId};
 use ir::traversal::EdgeKind;
 use ir::comp::{CompKind, Field, FieldMethods};
 use ir::ty::TypeKind;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use {HashMap, HashSet};
 
 /// An analysis that finds for each IR item whether it has a destructor or not
 ///
@@ -73,7 +72,7 @@ impl<'ctx> MonotoneFramework for HasDestructorAnalysis<'ctx> {
     type Output = HashSet<ItemId>;
 
     fn new(ctx: &'ctx BindgenContext) -> Self {
-        let have_destructor = HashSet::new();
+        let have_destructor = HashSet::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         HasDestructorAnalysis {
diff --git a/src/ir/analysis/has_float.rs b/src/ir/analysis/has_float.rs
@@ -1,8 +1,7 @@
 //! Determining which types has float.
 
 use super::{ConstrainResult, MonotoneFramework, generate_dependencies};
-use std::collections::HashSet;
-use std::collections::HashMap;
+use {HashSet, HashMap};
 use ir::context::{BindgenContext, ItemId};
 use ir::traversal::EdgeKind;
 use ir::ty::TypeKind;
@@ -84,7 +83,7 @@ impl<'ctx> MonotoneFramework for HasFloat<'ctx> {
     type Output = HashSet<ItemId>;
 
     fn new(ctx: &'ctx BindgenContext) -> HasFloat<'ctx> {
-        let has_float = HashSet::new();
+        let has_float = HashSet::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         HasFloat {
diff --git a/src/ir/analysis/has_type_param_in_array.rs b/src/ir/analysis/has_type_param_in_array.rs
@@ -6,8 +6,7 @@ use ir::comp::FieldMethods;
 use ir::context::{BindgenContext, ItemId};
 use ir::traversal::EdgeKind;
 use ir::ty::TypeKind;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use {HashMap, HashSet};
 
 /// An analysis that finds for each IR item whether it has array or not.
 ///
@@ -92,7 +91,7 @@ impl<'ctx> MonotoneFramework for HasTypeParameterInArray<'ctx> {
     fn new(
         ctx: &'ctx BindgenContext,
     ) -> HasTypeParameterInArray<'ctx> {
-        let has_type_parameter_in_array = HashSet::new();
+        let has_type_parameter_in_array = HashSet::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         HasTypeParameterInArray {
diff --git a/src/ir/analysis/has_vtable.rs b/src/ir/analysis/has_vtable.rs
@@ -5,9 +5,8 @@ use ir::context::{BindgenContext, ItemId};
 use ir::traversal::EdgeKind;
 use ir::ty::TypeKind;
 use std::cmp;
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
 use std::ops;
+use {HashMap, Entry};
 
 /// The result of the `HasVtableAnalysis` for an individual item.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)]
@@ -148,7 +147,7 @@ impl<'ctx> MonotoneFramework for HasVtableAnalysis<'ctx> {
     type Output = HashMap<ItemId, HasVtableResult>;
 
     fn new(ctx: &'ctx BindgenContext) -> HasVtableAnalysis<'ctx> {
-        let have_vtable = HashMap::new();
+        let have_vtable = HashMap::default();
         let dependencies = generate_dependencies(ctx, Self::consider_edge);
 
         HasVtableAnalysis {
diff --git a/src/ir/analysis/mod.rs b/src/ir/analysis/mod.rs
@@ -64,7 +64,7 @@ pub use self::sizedness::{Sizedness, SizednessAnalysis, SizednessResult};
 use ir::context::{BindgenContext, ItemId};
 
 use ir::traversal::{EdgeKind, Trace};
-use std::collections::HashMap;
+use HashMap;
 use std::fmt;
 use std::ops;
 
@@ -190,7 +190,7 @@ pub fn generate_dependencies<F>(
 where
     F: Fn(EdgeKind) -> bool,
 {
-    let mut dependencies = HashMap::new();
+    let mut dependencies = HashMap::default();
 
     for &item in ctx.whitelisted_items() {
         dependencies.entry(item).or_insert(vec![]);
@@ -219,7 +219,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::collections::{HashMap, HashSet};
+    use {HashMap, HashSet};
 
     // Here we find the set of nodes that are reachable from any given
     // node. This is a lattice mapping nodes to subsets of all nodes. Our join
@@ -334,14 +334,14 @@ mod tests {
             // implementation. Don't copy this code outside of this test!
 
             let original_size =
-                self.reachable.entry(node).or_insert(HashSet::new()).len();
+                self.reachable.entry(node).or_insert(HashSet::default()).len();
 
             for sub_node in self.graph.0[&node].iter() {
                 self.reachable.get_mut(&node).unwrap().insert(*sub_node);
 
                 let sub_reachable = self.reachable
                     .entry(*sub_node)
-                    .or_insert(HashSet::new())
+                    .or_insert(HashSet::default())
                     .clone();
 
                 for transitive in sub_reachable {
@@ -386,7 +386,7 @@ mod tests {
             nodes.as_ref().iter().cloned().map(Node).collect()
         }
 
-        let mut expected = HashMap::new();
+        let mut expected = HashMap::default();
         expected.insert(Node(1), nodes([3, 4, 5, 6, 7, 8]));
         expected.insert(Node(2), nodes([2]));
         expected.insert(Node(3), nodes([3, 4, 5, 6, 7, 8]));
diff --git a/src/ir/analysis/sizedness.rs b/src/ir/analysis/sizedness.rs
@@ -5,10 +5,8 @@ use ir::context::{BindgenContext, TypeId};
 use ir::item::IsOpaque;
 use ir::traversal::EdgeKind;
 use ir::ty::TypeKind;
-use std::cmp;
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
-use std::ops;
+use std::{cmp, ops};
+use {HashMap, Entry};
 
 /// The result of the `Sizedness` analysis for an individual item.
 ///
@@ -194,7 +192,7 @@ impl<'ctx> MonotoneFramework for SizednessAnalysis<'ctx> {
             })
             .collect();
 
-        let sized = HashMap::new();
+        let sized = HashMap::default();
 
         SizednessAnalysis {
             ctx,
diff --git a/src/ir/analysis/template_params.rs b/src/ir/analysis/template_params.rs
@@ -94,7 +94,7 @@ use ir::item::{Item, ItemSet};
 use ir::template::{TemplateInstantiation, TemplateParameters};
 use ir::traversal::{EdgeKind, Trace};
 use ir::ty::TypeKind;
-use std::collections::{HashMap, HashSet};
+use {HashMap, HashSet};
 
 /// An analysis that finds for each IR item its set of template parameters that
 /// it uses.
@@ -373,8 +373,8 @@ impl<'ctx> MonotoneFramework for UsedTemplateParameters<'ctx> {
     fn new(
         ctx: &'ctx BindgenContext,
     ) -> UsedTemplateParameters<'ctx> {
-        let mut used = HashMap::new();
-        let mut dependencies = HashMap::new();
+        let mut used = HashMap::default();
+        let mut dependencies = HashMap::default();
         let whitelisted_items: HashSet<_> =
             ctx.whitelisted_items().iter().cloned().collect();
 
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
@@ -17,7 +17,7 @@ use peeking_take_while::PeekableExt;
 use std::cmp;
 use std::io;
 use std::mem;
-use std::collections::HashMap;
+use HashMap;
 
 /// The kind of compound type.
 #[derive(Debug, Copy, Clone, PartialEq)]
diff --git a/src/ir/context.rs b/src/ir/context.rs
diff --git a/src/ir/dot.rs b/src/ir/dot.rs
diff --git a/src/ir/objc.rs b/src/ir/objc.rs
diff --git a/src/lib.rs b/src/lib.rs
