This speeds up compilation by 3--6% across most of rustc-benchmarks.
// except according to those terms.
use hir::def_id::DefId;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use std::cell::RefCell;
use std::ops::Index;
use std::hash::Hash;
pub struct DepTrackingMap<M: DepTrackingMapConfig> {
phantom: PhantomData<M>,
graph: DepGraph,
- map: FnvHashMap<M::Key, M::Value>,
+ map: FxHashMap<M::Key, M::Value>,
}
pub trait DepTrackingMapConfig {
DepTrackingMap {
phantom: PhantomData,
graph: graph,
- map: FnvHashMap()
+ map: FxHashMap()
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rustc_data_structures::fnv::{FnvHashMap, FnvHashSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use std::fmt::Debug;
use std::hash::Hash;
use super::{DepGraphQuery, DepNode};
pub struct DepGraphEdges<D: Clone + Debug + Eq + Hash> {
nodes: Vec<DepNode<D>>,
- indices: FnvHashMap<DepNode<D>, IdIndex>,
- edges: FnvHashSet<(IdIndex, IdIndex)>,
+ indices: FxHashMap<DepNode<D>, IdIndex>,
+ edges: FxHashSet<(IdIndex, IdIndex)>,
open_nodes: Vec<OpenNode>,
}
pub fn new() -> DepGraphEdges<D> {
DepGraphEdges {
nodes: vec![],
- indices: FnvHashMap(),
- edges: FnvHashSet(),
+ indices: FxHashMap(),
+ edges: FxHashSet(),
open_nodes: Vec::new()
}
}
// except according to those terms.
use hir::def_id::DefId;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use session::config::OutputType;
use std::cell::{Ref, RefCell};
use std::rc::Rc;
/// things available to us. If we find that they are not dirty, we
/// load the path to the file storing those work-products here into
/// this map. We can later look for and extract that data.
- previous_work_products: RefCell<F
nvHashMap<Arc<WorkProductId>, WorkProduct>>,
+ previous_work_products: RefCell<F
xHashMap<Arc<WorkProductId>, WorkProduct>>,
/// Work-products that we generate in this run.
- work_products: RefCell<F
nvHashMap<Arc<WorkProductId>, WorkProduct>>,
+ work_products: RefCell<F
xHashMap<Arc<WorkProductId>, WorkProduct>>,
}
impl DepGraph {
DepGraph {
data: Rc::new(DepGraphData {
thread: DepGraphThreadData::new(enabled),
- previous_work_products: RefCell::new(FnvHashMap()),
- work_products: RefCell::new(FnvHashMap()),
+ previous_work_products: RefCell::new(FxHashMap()),
+ work_products: RefCell::new(FxHashMap()),
})
}
}
/// Access the map of work-products created during this run. Only
/// used during saving of the dep-graph.
- pub fn work_products(&self) -> Ref<F
nvHashMap<Arc<WorkProductId>, WorkProduct>> {
+ pub fn work_products(&self) -> Ref<F
xHashMap<Arc<WorkProductId>, WorkProduct>> {
self.data.work_products.borrow()
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::graph::{Direction, INCOMING, Graph, NodeIndex, OUTGOING};
use std::fmt::Debug;
use std::hash::Hash;
pub struct DepGraphQuery<D: Clone + Debug + Hash + Eq> {
pub graph: Graph<DepNode<D>, ()>,
- pub indices: FnvHashMap<DepNode<D>, NodeIndex>,
+ pub indices: FxHashMap<DepNode<D>, NodeIndex>,
}
impl<D: Clone + Debug + Hash + Eq> DepGraphQuery<D> {
edges: &[(DepNode<D>, DepNode<D>)])
-> DepGraphQuery<D> {
let mut graph = Graph::new();
- let mut indices = FnvHashMap();
+ let mut indices = FxHashMap();
for node in nodes {
indices.insert(node.clone(), graph.next_node_index());
graph.add_node(node.clone());
// except according to those terms.
use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use std::fmt::Write;
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;
#[derive(Clone)]
pub struct Definitions {
data: Vec<DefData>,
- key_map: FnvHashMap<DefKey, DefIndex>,
+ key_map: FxHashMap<DefKey, DefIndex>,
node_map: NodeMap<DefIndex>,
}
pub fn new() -> Definitions {
Definitions {
data: vec![],
- key_map: FnvHashMap(),
+ key_map: FxHashMap(),
node_map: NodeMap(),
}
}
use hir::def::Def;
use hir::def_id::DefId;
-use util::nodemap::{NodeMap, FnvHashSet};
+use util::nodemap::{NodeMap, FxHashSet};
use syntax_pos::{mk_sp, Span, ExpnId, DUMMY_SP};
use syntax::codemap::{self, respan, Spanned};
// Map from the NodeId of a glob import to a list of items which are actually
// imported.
-pub type GlobMap = NodeMap<FnvHashSet<Name>>;
+pub type GlobMap = NodeMap<FxHashSet<Name>>;
use ty::{self, Ty, TyCtxt, TypeFoldable};
use ty::fold::TypeFolder;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use std::collections::hash_map::Entry;
use super::InferCtxt;
pub struct TypeFreshener<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
freshen_count: u32,
- freshen_map: FnvHashMap<ty::InferTy, Ty<'tcx>>,
+ freshen_map: FxHashMap<ty::InferTy, Ty<'tcx>>,
}
impl<'a, 'gcx, 'tcx> TypeFreshener<'a, 'gcx, 'tcx> {
TypeFreshener {
infcx: infcx,
freshen_count: 0,
- freshen_map: FnvHashMap(),
+ freshen_map: FxHashMap(),
}
}
use ty::error::TypeError;
use ty::relate::{Relate, RelateResult, TypeRelation};
use syntax_pos::Span;
-use util::nodemap::{FnvHashMap, FnvHashSet};
+use util::nodemap::{FxHashMap, FxHashSet};
pub struct HrMatchResult<U> {
pub value: U,
// Map each skolemized region to a vector of other regions that it
// must be equated with. (Note that this vector may include other
// skolemized regions from `skol_map`.)
- let skol_resolution_map: FnvHashMap<_, _> =
+ let skol_resolution_map: FxHashMap<_, _> =
skol_map
.iter()
.map(|(&br, &skol)| {
// `skol_map`. There should always be a representative if things
// are properly well-formed.
let mut unconstrained_regions = vec![];
- let skol_representatives: FnvHashMap<_, _> =
+ let skol_representatives: FxHashMap<_, _> =
skol_resolution_map
.iter()
.map(|(&skol, &(br, ref regions))| {
snapshot: &CombinedSnapshot,
debruijn: ty::DebruijnIndex,
new_vars: &[ty::RegionVid],
- a_map: &FnvHashMap<ty::BoundRegion, &'tcx ty::Region>,
+ a_map: &FxHashMap<ty::BoundRegion, &'tcx ty::Region>,
r0: &'tcx ty::Region)
-> &'tcx ty::Region {
// Regions that pre-dated the LUB computation stay as they are.
snapshot: &CombinedSnapshot,
debruijn: ty::DebruijnIndex,
new_vars: &[ty::RegionVid],
- a_map: &FnvHashMap<ty::BoundRegion,
- &'tcx ty::Region>,
+ a_map: &FxHashMap<ty::BoundRegion, &'tcx ty::Region>,
a_vars: &[ty::RegionVid],
b_vars: &[ty::RegionVid],
r0: &'tcx ty::Region)
fn rev_lookup<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
span: Span,
- a_map: &FnvHashMap<ty::BoundRegion, &'tcx ty::Region>,
+ a_map: &FxHashMap<ty::BoundRegion, &'tcx ty::Region>,
r: &'tcx ty::Region) -> &'tcx ty::Region
{
for (a_br, a_r) in a_map {
}
fn var_ids<'a, 'gcx, 'tcx>(fields: &CombineFields<'a, 'gcx, 'tcx>,
- map: &FnvHashMap<ty::BoundRegion, &'tcx ty::Region>)
+ map: &FxHashMap<ty::BoundRegion, &'tcx ty::Region>)
-> Vec<ty::RegionVid> {
map.iter()
.map(|(_, &r)| match *r {
snapshot: &CombinedSnapshot,
r: &'tcx ty::Region,
directions: TaintDirections)
- -> FnvHashSet<&'tcx ty::Region> {
+ -> FxHashSet<&'tcx ty::Region> {
self.region_vars.tainted(&snapshot.region_vars_snapshot, r, directions)
}
let escaping_types =
self.type_variables.borrow_mut().types_escaping_snapshot(&snapshot.type_snapshot);
- let mut escaping_region_vars = FnvHashSet();
+ let mut escaping_region_vars = FxHashSet();
for ty in &escaping_types {
self.tcx.collect_regions(ty, &mut escaping_region_vars);
}
// region back to the `ty::BoundRegion` that it originally
// represented. Because `leak_check` passed, we know that
// these taint sets are mutually disjoint.
- let inv_skol_map: FnvHashMap<&'tcx ty::Region, ty::BoundRegion> =
+ let inv_skol_map: FxHashMap<&'tcx ty::Region, ty::BoundRegion> =
skol_map
.iter()
.flat_map(|(&skol_br, &skol)| {
snapshot: &CombinedSnapshot)
{
debug!("pop_skolemized({:?})", skol_map);
- let skol_regions: FnvHashSet<_> = skol_map.values().cloned().collect();
+ let skol_regions: FxHashSet<_> = skol_map.values().cloned().collect();
self.region_vars.pop_skolemized(&skol_regions, &snapshot.region_vars_snapshot);
if !skol_map.is_empty() {
self.projection_cache.borrow_mut().rollback_skolemized(
use syntax::ast;
use errors::DiagnosticBuilder;
use syntax_pos::{self, Span, DUMMY_SP};
-use util::nodemap::{FnvHashMap, FnvHashSet, NodeMap};
+use util::nodemap::{FxHashMap, FxHashSet, NodeMap};
use self::combine::CombineFields;
use self::higher_ranked::HrMatchResult;
// the set of predicates on which errors have been reported, to
// avoid reporting the same error twice.
- pub reported_trait_errors: RefCell<FnvHashSet<traits::TraitErrorKey<'tcx>>>,
+ pub reported_trait_errors: RefCell<FxHashSet<traits::TraitErrorKey<'tcx>>>,
// Sadly, the behavior of projection varies a bit depending on the
// stage of compilation. The specifics are given in the
/// A map returned by `skolemize_late_bound_regions()` indicating the skolemized
/// region that each late-bound region was replaced with.
-pub type SkolemizationMap<'tcx> = FnvHashMap<ty::BoundRegion, &'tcx ty::Region>;
+pub type SkolemizationMap<'tcx> = FxHashMap<ty::BoundRegion, &'tcx ty::Region>;
/// Why did we require that the two types be related?
///
selection_cache: traits::SelectionCache::new(),
evaluation_cache: traits::EvaluationCache::new(),
projection_cache: RefCell::new(traits::ProjectionCache::new()),
- reported_trait_errors: RefCell::new(FnvHashSet()),
+ reported_trait_errors: RefCell::new(FxHashSet()),
projection_mode: Reveal::NotSpecializable,
tainted_by_errors_flag: Cell::new(false),
err_count_on_creation: self.sess.err_count(),
parameter_environment: param_env,
selection_cache: traits::SelectionCache::new(),
evaluation_cache: traits::EvaluationCache::new(),
- reported_trait_errors: RefCell::new(FnvHashSet()),
+ reported_trait_errors: RefCell::new(FxHashSet()),
projection_mode: projection_mode,
tainted_by_errors_flag: Cell::new(false),
err_count_on_creation: tcx.sess.err_count(),
span: Span,
lbrct: LateBoundRegionConversionTime,
value: &ty::Binder<T>)
- -> (T, FnvHashMap<ty::BoundRegion, &'tcx ty::Region>)
+ -> (T, FxHashMap<ty::BoundRegion, &'tcx ty::Region>)
where T : TypeFoldable<'tcx>
{
self.tcx.replace_late_bound_regions(
use super::Constraint;
use infer::SubregionOrigin;
use infer::region_inference::RegionVarBindings;
-use util::nodemap::{FnvHashMap, FnvHashSet};
+use util::nodemap::{FxHashMap, FxHashSet};
use std::borrow::Cow;
use std::collections::hash_map::Entry::Vacant;
struct ConstraintGraph<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
graph_name: String,
- map: &'a FnvHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>,
- node_ids: FnvHashMap<Node, usize>,
+ map: &'a FxHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>,
+ node_ids: FxHashMap<Node, usize>,
}
#[derive(Clone, Hash, PartialEq, Eq, Debug, Copy)]
map: &'a ConstraintMap<'tcx>)
-> ConstraintGraph<'a, 'gcx, 'tcx> {
let mut i = 0;
- let mut node_ids = FnvHashMap();
+ let mut node_ids = FxHashMap();
{
let mut add_node = |node| {
if let Vacant(e) = node_ids.entry(node) {
type Node = Node;
type Edge = Edge<'tcx>;
fn nodes(&self) -> dot::Nodes<Node> {
- let mut set = FnvHashSet();
+ let mut set = FxHashSet();
for node in self.node_ids.keys() {
set.insert(*node);
}
}
}
-pub type ConstraintMap<'tcx> = FnvHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>;
+pub type ConstraintMap<'tcx> = FxHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>;
fn dump_region_constraints_to<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
map: &ConstraintMap<'tcx>,
use super::{RegionVariableOrigin, SubregionOrigin, MiscVariable};
use super::unify_key;
-use rustc_data_structures::fnv::{FnvHashMap, FnvHashSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::graph::{self, Direction, NodeIndex, OUTGOING};
use rustc_data_structures::unify::{self, UnificationTable};
use middle::free_region::FreeRegionMap;
}
}
-pub type CombineMap<'tcx> = FnvHashMap<TwoRegions<'tcx>, RegionVid>;
+pub type CombineMap<'tcx> = FxHashMap<TwoRegions<'tcx>, RegionVid>;
pub struct RegionVarBindings<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
// Constraints of the form `A <= B` introduced by the region
// checker. Here at least one of `A` and `B` must be a region
// variable.
- constraints: RefCell<FnvHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>>,
+ constraints: RefCell<FxHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>>,
// A "verify" is something that we need to verify after inference is
// done, but which does not directly affect inference in any way.
// record the fact that `'a <= 'b` is implied by the fn signature,
// and then ignore the constraint when solving equations. This is
// a bit of a hack but seems to work.
- givens: RefCell<FnvHashSet<(ty::FreeRegion, ty::RegionVid)>>,
+ givens: RefCell<FxHashSet<(ty::FreeRegion, ty::RegionVid)>>,
lubs: RefCell<CombineMap<'tcx>>,
glbs: RefCell<CombineMap<'tcx>>,
struct TaintSet<'tcx> {
directions: TaintDirections,
- regions: FnvHashSet<&'tcx ty::Region>
+ regions: FxHashSet<&'tcx ty::Region>
}
impl<'a, 'gcx, 'tcx> TaintSet<'tcx> {
fn new(directions: TaintDirections,
initial_region: &'tcx ty::Region)
-> Self {
- let mut regions = FnvHashSet();
+ let mut regions = FxHashSet();
regions.insert(initial_region);
TaintSet { directions: directions, regions: regions }
}
}
}
- fn into_set(self) -> FnvHashSet<&'tcx ty::Region> {
+ fn into_set(self) -> FxHashSet<&'tcx ty::Region> {
self.regions
}
tcx: tcx,
var_origins: RefCell::new(Vec::new()),
values: RefCell::new(None),
- constraints: RefCell::new(FnvHashMap()),
+ constraints: RefCell::new(FxHashMap()),
verifys: RefCell::new(Vec::new()),
- givens: RefCell::new(FnvHashSet()),
- lubs: RefCell::new(FnvHashMap()),
- glbs: RefCell::new(FnvHashMap()),
+ givens: RefCell::new(FxHashSet()),
+ lubs: RefCell::new(FxHashMap()),
+ glbs: RefCell::new(FxHashMap()),
skolemization_count: Cell::new(0),
bound_count: Cell::new(0),
undo_log: RefCell::new(Vec::new()),
/// completes to remove all trace of the skolemized regions
/// created in that time.
pub fn pop_skolemized(&self,
- skols: &FnvHashSet<&'tcx ty::Region>,
+ skols: &FxHashSet<&'tcx ty::Region>,
snapshot: &RegionSnapshot) {
debug!("pop_skolemized_regions(skols={:?})", skols);
self.skolemization_count.set(snapshot.skolemization_count);
return;
- fn kill_constraint<'tcx>(skols: &FnvHashSet<&'tcx ty::Region>,
+ fn kill_constraint<'tcx>(skols: &FxHashSet<&'tcx ty::Region>,
undo_entry: &UndoLogEntry<'tcx>)
-> bool {
match undo_entry {
mark: &RegionSnapshot,
r0: &'tcx Region,
directions: TaintDirections)
- -> FnvHashSet<&'tcx ty::Region> {
+ -> FxHashSet<&'tcx ty::Region> {
debug!("tainted(mark={:?}, r0={:?}, directions={:?})",
mark, r0, directions);
dup_vec: &mut [u32])
-> (Vec<RegionAndOrigin<'tcx>>, bool) {
struct WalkState<'tcx> {
- set: FnvHashSet<RegionVid>,
+ set: FxHashSet<RegionVid>,
stack: Vec<RegionVid>,
result: Vec<RegionAndOrigin<'tcx>>,
dup_found: bool,
}
let mut state = WalkState {
- set: FnvHashSet(),
+ set: FxHashSet(),
stack: vec![orig_node_idx],
result: Vec::new(),
dup_found: false,
use lint::{EarlyLintPassObject, LateLintPassObject};
use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid};
use lint::builtin;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use std::cmp;
use std::default::Default as StdDefault;
late_passes: Option<Vec<LateLintPassObject>>,
/// Lints indexed by name.
- by_name: FnvHashMap<String, TargetLint>,
+ by_name: FxHashMap<String, TargetLint>,
/// Current levels of each lint, and where they were set.
- levels: FnvHashMap<LintId, LevelSource>,
+ levels: FxHashMap<LintId, LevelSource>,
/// Map of registered lint groups to what lints they expand to. The bool
/// is true if the lint group was added by a plugin.
- lint_groups: FnvHashMap<&'static str, (Vec<LintId>, bool)>,
+ lint_groups: FxHashMap<&'static str, (Vec<LintId>, bool)>,
/// Extra info for future incompatibility lints, descibing the
/// issue or RFC that caused the incompatibility.
- future_incompatible: FnvHashMap<LintId, FutureIncompatibleInfo>,
+ future_incompatible: FxHashMap<LintId, FutureIncompatibleInfo>,
/// Maximum level a lint can be
lint_cap: Option<Level>,
lints: vec![],
early_passes: Some(vec![]),
late_passes: Some(vec![]),
- by_name: FnvHashMap(),
- levels: FnvHashMap(),
- future_incompatible: FnvHashMap(),
- lint_groups: FnvHashMap(),
+ by_name: FxHashMap(),
+ levels: FxHashMap(),
+ future_incompatible: FxHashMap(),
+ lint_groups: FxHashMap(),
lint_cap: None,
}
}
Err(FindLintError::Removed) => { }
Err(_) => {
match self.lint_groups.iter().map(|(&x, pair)| (x, pair.0.clone()))
- .collect::<FnvHashMap<&'static str,
- Vec<LintId>>>()
+ .collect::<FxHashMap<&'static str,
+ Vec<LintId>>>()
.get(&lint_name[..]) {
Some(v) => {
v.iter()
use hir::def::Def;
use hir::def_id::{DefId};
use lint;
-use util::nodemap::FnvHashSet;
+use util::nodemap::FxHashSet;
use syntax::{ast, codemap};
use syntax::attr;
struct MarkSymbolVisitor<'a, 'tcx: 'a> {
worklist: Vec<ast::NodeId>,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- live_symbols: Box<F
nvHashSet<ast::NodeId>>,
+ live_symbols: Box<F
xHashSet<ast::NodeId>>,
struct_has_extern_repr: bool,
ignore_non_const_paths: bool,
inherited_pub_visibility: bool,
MarkSymbolVisitor {
worklist: worklist,
tcx: tcx,
- live_symbols: box FnvHashSet(),
+ live_symbols: box FxHashSet(),
struct_has_extern_repr: false,
ignore_non_const_paths: false,
inherited_pub_visibility: false,
}
fn mark_live_symbols(&mut self) {
- let mut scanned = FnvHashSet();
+ let mut scanned = FxHashSet();
while !self.worklist.is_empty() {
let id = self.worklist.pop().unwrap();
if scanned.contains(&id) {
fn find_live<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
access_levels: &privacy::AccessLevels,
krate: &hir::Crate)
- -> Box<F
nvHashSet<ast::NodeId>> {
+ -> Box<F
xHashSet<ast::NodeId>> {
let worklist = create_and_seed_worklist(tcx, access_levels, krate);
let mut symbol_visitor = MarkSymbolVisitor::new(tcx, worklist);
symbol_visitor.mark_live_symbols();
struct DeadVisitor<'a, 'tcx: 'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- live_symbols: Box<F
nvHashSet<ast::NodeId>>,
+ live_symbols: Box<F
xHashSet<ast::NodeId>>,
}
impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
use session;
use session::config;
use middle::cstore::LinkagePreference::{self, RequireStatic, RequireDynamic};
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use rustc_back::PanicStrategy;
/// A list of dependencies for a certain crate type.
/// A mapping of all required dependencies for a particular flavor of output.
///
/// This is local to the tcx, and is generally relevant to one session.
-pub type Dependencies = FnvHashMap<config::CrateType, DependencyList>;
+pub type Dependencies = FxHashMap<config::CrateType, DependencyList>;
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum Linkage {
config::CrateTypeProcMacro => {},
}
- let mut formats = FnvHashMap();
+ let mut formats = FxHashMap();
// Sweep all crates for found dylibs. Add all dylibs, as well as their
// dependencies, ensuring there are no conflicts. The only valid case for a
fn add_library(sess: &session::Session,
cnum: CrateNum,
link: LinkagePreference,
- m: &mut FnvHashMap<CrateNum, LinkagePreference>) {
+ m: &mut FxHashMap<CrateNum, LinkagePreference>) {
match m.get(&cnum) {
Some(&link2) => {
// If the linkages differ, then we'd have two copies of the library
use hir::def_id::DefId;
use ty;
use middle::weak_lang_items;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use syntax::ast;
use syntax::parse::token::InternedString;
session: &'a Session,
- item_refs: FnvHashMap<&'static str, usize>,
+ item_refs: FxHashMap<&'static str, usize>,
}
impl<'a, 'v, 'tcx> Visitor<'v> for LanguageItemCollector<'a, 'tcx> {
impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> {
pub fn new(session: &'a Session, ast_map: &'a hir_map::Map<'tcx>)
-> LanguageItemCollector<'a, 'tcx> {
- let mut item_refs = FnvHashMap();
+ let mut item_refs = FxHashMap();
$( item_refs.insert($name, $variant as usize); )*
//! outside their scopes. This pass will also generate a set of exported items
//! which are available for use externally when compiled as a library.
-use util::nodemap::{DefIdSet, FnvHashMap};
+use util::nodemap::{DefIdSet, FxHashMap};
use std::hash::Hash;
use std::fmt;
// Accessibility levels for reachable HIR nodes
#[derive(Clone)]
pub struct AccessLevels<Id = NodeId> {
- pub map: FnvHashMap<Id, AccessLevel>
+ pub map: FxHashMap<Id, AccessLevel>
}
impl<Id: Hash + Eq> AccessLevels<Id> {
use ty::{self, TyCtxt};
use middle::privacy;
use session::config;
-use util::nodemap::{NodeSet, FnvHashSet};
+use util::nodemap::{NodeSet, FxHashSet};
use syntax::abi::Abi;
use syntax::ast;
// Step 2: Mark all symbols that the symbols on the worklist touch.
fn propagate(&mut self) {
- let mut scanned = FnvHashSet();
+ let mut scanned = FxHashSet();
loop {
let search_item = match self.worklist.pop() {
Some(item) => item,
use dep_graph::DepNode;
use hir::map as ast_map;
use session::Session;
-use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
+use util::nodemap::{FxHashMap, NodeMap, NodeSet};
use ty;
use std::cell::RefCell;
/// The region maps encode information about region relationships.
pub struct RegionMaps {
code_extents: RefCell<Vec<CodeExtentData>>,
- code_extent_interner: RefCell<FnvHashMap<CodeExtentData, CodeExtent>>,
+ code_extent_interner: RefCell<FxHashMap<CodeExtentData, CodeExtent>>,
/// `scope_map` maps from a scope id to the enclosing scope id;
/// this is usually corresponding to the lexical nesting, though
/// in the case of closures the parent scope is the innermost
let maps = RegionMaps {
code_extents: RefCell::new(vec![]),
- code_extent_interner: RefCell::new(FnvHashMap()),
+ code_extent_interner: RefCell::new(FxHashMap()),
scope_map: RefCell::new(vec![]),
var_map: RefCell::new(NodeMap()),
rvalue_scopes: RefCell::new(NodeMap()),
use syntax_pos::Span;
use util::nodemap::NodeMap;
-use rustc_data_structures::fnv::FnvHashSet;
+use rustc_data_structures::fx::FxHashSet;
use hir;
use hir::print::lifetime_to_string;
use hir::intravisit::{self, Visitor, FnKind};
generics: &hir::Generics) {
debug!("insert_late_bound_lifetimes(decl={:?}, generics={:?})", decl, generics);
- let mut constrained_by_input = ConstrainedCollector { regions: FnvHashSet() };
+ let mut constrained_by_input = ConstrainedCollector { regions: FxHashSet() };
for arg in &decl.inputs {
constrained_by_input.visit_ty(&arg.ty);
}
let mut appears_in_output = AllCollector {
- regions: FnvHashSet(),
+ regions: FxHashSet(),
impl_trait: false
};
intravisit::walk_fn_ret_ty(&mut appears_in_output, &decl.output);
// Subtle point: because we disallow nested bindings, we can just
// ignore binders here and scrape up all names we see.
let mut appears_in_where_clause = AllCollector {
- regions: FnvHashSet(),
+ regions: FxHashSet(),
impl_trait: false
};
for ty_param in generics.ty_params.iter() {
return;
struct ConstrainedCollector {
- regions: F
nvHashSet<ast::Name>,
+ regions: F
xHashSet<ast::Name>,
}
impl<'v> Visitor<'v> for ConstrainedCollector {
}
struct AllCollector {
- regions: F
nvHashSet<ast::Name>,
+ regions: F
xHashSet<ast::Name>,
impl_trait: bool
}
use syntax::ast::{NodeId, Attribute};
use syntax::feature_gate::{GateIssue, emit_feature_err, find_lang_feature_accepted_version};
use syntax::attr::{self, Stability, Deprecation};
-use util::nodemap::{DefIdMap, FnvHashSet, FnvHashMap};
+use util::nodemap::{DefIdMap, FxHashSet, FxHashMap};
use hir;
use hir::{Item, Generics, StructField, Variant, PatKind};
depr_map: DefIdMap<Option<DeprecationEntry>>,
/// Maps for each crate whether it is part of the staged API.
- staged_api: FnvHashMap<CrateNum, bool>
+ staged_api: FxHashMap<CrateNum, bool>
}
// A private tree-walker for producing an Index.
}
}
- let mut staged_api = FnvHashMap();
+ let mut staged_api = FxHashMap();
staged_api.insert(LOCAL_CRATE, is_staged_api);
Index {
staged_api: staged_api,
/// features and possibly prints errors. Returns a list of all
/// features used.
pub fn check_unstable_api_usage<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
- -> FnvHashMap<InternedString, attr::StabilityLevel> {
+ -> FxHashMap<InternedString, attr::StabilityLevel> {
let _task = tcx.dep_graph.in_task(DepNode::StabilityCheck);
let ref active_lib_features = tcx.sess.features.borrow().declared_lib_features;
let mut checker = Checker {
tcx: tcx,
active_features: active_features,
- used_features: FnvHashMap(),
+ used_features: FxHashMap(),
in_skip_block: 0,
};
intravisit::walk_crate(&mut checker, tcx.map.krate());
struct Checker<'a, 'tcx: 'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- active_features: FnvHashSet<InternedString>,
- used_features: FnvHashMap<InternedString, attr::StabilityLevel>,
+ active_features: FxHashSet<InternedString>,
+ used_features: FxHashMap<InternedString, attr::StabilityLevel>,
// Within a block where feature gate checking can be skipped.
in_skip_block: u32,
}
/// were expected to be library features), and the list of features used from
/// libraries, identify activated features that don't exist and error about them.
pub fn check_unused_or_stable_features(sess: &Session,
- lib_features_used: &FnvHashMap<InternedString,
- attr::StabilityLevel>) {
+ lib_features_used: &FxHashMap<InternedString,
+ attr::StabilityLevel>) {
let ref declared_lib_features = sess.features.borrow().declared_lib_features;
- let mut remaining_lib_features: FnvHashMap<InternedString, Span>
+ let mut remaining_lib_features: FxHashMap<InternedString, Span>
= declared_lib_features.clone().into_iter().collect();
fn format_stable_since_msg(version: &str) -> String {
use session::search_paths::PathKind;
use session::config::DebugInfoLevel;
use ty::tls;
-use util::nodemap::{NodeMap, FnvHashMap, FnvHashSet};
+use util::nodemap::{NodeMap, FxHashMap, FxHashSet};
use util::common::duration_to_secs_str;
use mir::transform as mir_pass;
/// Set of (LintId, span, message) tuples tracking lint (sub)diagnostics
/// that have been set once, but should not be set again, in order to avoid
/// redundantly verbose output (Issue #24690).
- pub one_time_diagnostics: RefCell<FnvHashSet<(lint::LintId, Span, String)>>,
+ pub one_time_diagnostics: RefCell<FxHashSet<(lint::LintId, Span, String)>>,
pub plugin_llvm_passes: RefCell<Vec<String>>,
pub mir_passes: RefCell<mir_pass::Passes>,
pub plugin_attributes: RefCell<Vec<(String, AttributeType)>>,
working_dir: env::current_dir().unwrap(),
lint_store: RefCell::new(lint::LintStore::new()),
lints: RefCell::new(NodeMap()),
- one_time_diagnostics: RefCell::new(FnvHashSet()),
+ one_time_diagnostics: RefCell::new(FxHashSet()),
plugin_llvm_passes: RefCell::new(Vec::new()),
mir_passes: RefCell::new(mir_pass::Passes::new()),
plugin_attributes: RefCell::new(Vec::new()),
crate_types: RefCell::new(Vec::new()),
- dependency_formats: RefCell::new(FnvHashMap()),
+ dependency_formats: RefCell::new(FxHashMap()),
crate_disambiguator: RefCell::new(token::intern("").as_str()),
features: RefCell::new(feature_gate::Features::new()),
recursion_limit: Cell::new(64),
use ty::fast_reject;
use ty::fold::TypeFolder;
use ty::subst::Subst;
-use util::nodemap::{FnvHashMap, FnvHashSet};
+use util::nodemap::{FxHashMap, FxHashSet};
use std::cmp;
use std::fmt;
let generic_map = def.generics.types.iter().map(|param| {
(param.name.as_str().to_string(),
trait_ref.substs.type_for_def(param).to_string())
- }).collect::<FnvHashMap<String, String>>();
+ }).collect::<FxHashMap<String, String>>();
let parser = Parser::new(&istring);
let mut errored = false;
let err: String = parser.filter_map(|p| {
"the trait `{}` cannot be made into an object", trait_str
));
- let mut reported_violations = FnvHashSet();
+ let mut reported_violations = FxHashSet();
for violation in violations {
if !reported_violations.insert(violation.clone()) {
continue;
fn predicate_can_apply(&self, pred: ty::PolyTraitRef<'tcx>) -> bool {
struct ParamToVarFolder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
- var_map: FnvHashMap<Ty<'tcx>, Ty<'tcx>>
+ var_map: FxHashMap<Ty<'tcx>, Ty<'tcx>>
}
impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for ParamToVarFolder<'a, 'gcx, 'tcx> {
let cleaned_pred = pred.fold_with(&mut ParamToVarFolder {
infcx: self,
- var_map: FnvHashMap()
+ var_map: FxHashMap()
});
let cleaned_pred = super::project::normalize(
use std::mem;
use syntax::ast;
use util::common::ErrorReported;
-use util::nodemap::{FnvHashSet, NodeMap};
+use util::nodemap::{FxHashSet, NodeMap};
use super::CodeAmbiguity;
use super::CodeProjectionError;
}
pub struct GlobalFulfilledPredicates<'tcx> {
- set: FnvHashSet<ty::PolyTraitPredicate<'tcx>>,
+ set: FxHashSet<ty::PolyTraitPredicate<'tcx>>,
dep_graph: DepGraph,
}
impl<'a, 'gcx, 'tcx> GlobalFulfilledPredicates<'gcx> {
pub fn new(dep_graph: DepGraph) -> GlobalFulfilledPredicates<'gcx> {
GlobalFulfilledPredicates {
- set: FnvHashSet(),
+ set: FxHashSet(),
dep_graph: dep_graph,
}
}
use std::rc::Rc;
use syntax::abi::Abi;
use hir;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
struct InferredObligationsSnapshotVecDelegate<'tcx> {
phantom: PhantomData<&'tcx i32>,
#[derive(Clone)]
pub struct SelectionCache<'tcx> {
- hashmap: RefCell<FnvHashMap<ty::TraitRef<'tcx>,
- SelectionResult<'tcx, SelectionCandidate<'tcx>>>>,
+ hashmap: RefCell<FxHashMap<ty::TraitRef<'tcx>,
+ SelectionResult<'tcx, SelectionCandidate<'tcx>>>>,
}
pub enum MethodMatchResult {
#[derive(Clone)]
pub struct EvaluationCache<'tcx> {
- hashmap: RefCell<FnvHashMap<ty::PolyTraitRef<'tcx>, EvaluationResult>>
+ hashmap: RefCell<FxHashMap<ty::PolyTraitRef<'tcx>, EvaluationResult>>
}
impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
impl<'tcx> SelectionCache<'tcx> {
pub fn new() -> SelectionCache<'tcx> {
SelectionCache {
- hashmap: RefCell::new(FnvHashMap())
+ hashmap: RefCell::new(FxHashMap())
}
}
}
impl<'tcx> EvaluationCache<'tcx> {
pub fn new() -> EvaluationCache<'tcx> {
EvaluationCache {
- hashmap: RefCell::new(FnvHashMap())
+ hashmap: RefCell::new(FxHashMap())
}
}
}
use super::{SelectionContext, FulfillmentContext};
use super::util::impl_trait_ref_and_oblig;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use hir::def_id::DefId;
use infer::{InferCtxt, InferOk, TypeOrigin};
use middle::region;
}
pub struct SpecializesCache {
- map: FnvHashMap<(DefId, DefId), bool>
+ map: FxHashMap<(DefId, DefId), bool>
}
impl SpecializesCache {
pub fn new() -> Self {
SpecializesCache {
- map: FnvHashMap()
+ map: FxHashMap()
}
}
use ty::{self, TyCtxt, ImplOrTraitItem, TraitDef, TypeFoldable};
use ty::fast_reject::{self, SimplifiedType};
use syntax::ast::Name;
-use util::nodemap::{DefIdMap, FnvHashMap};
+use util::nodemap::{DefIdMap, FxHashMap};
/// A per-trait graph of impls in specialization order. At the moment, this
/// graph forms a tree rooted with the trait itself, with all other nodes
// the specialization graph.
/// Impls of the trait.
- nonblanket_impls: FnvHashMap<fast_reject::SimplifiedType, Vec<DefId>>,
+ nonblanket_impls: FxHashMap<fast_reject::SimplifiedType, Vec<DefId>>,
/// Blanket impls associated with the trait.
blanket_impls: Vec<DefId>,
impl<'a, 'gcx, 'tcx> Children {
fn new() -> Children {
Children {
- nonblanket_impls: FnvHashMap(),
+ nonblanket_impls: FxHashMap(),
blanket_impls: vec![],
}
}
use ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef};
use ty::outlives::Component;
use util::common::ErrorReported;
-use util::nodemap::FnvHashSet;
+use util::nodemap::FxHashSet;
use super::{Obligation, ObligationCause, PredicateObligation, SelectionContext, Normalized};
struct PredicateSet<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
- set: FnvHashSet<ty::Predicate<'tcx>>,
+ set: FxHashSet<ty::Predicate<'tcx>>,
}
impl<'a, 'gcx, 'tcx> PredicateSet<'a, 'gcx, 'tcx> {
fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> PredicateSet<'a, 'gcx, 'tcx> {
- PredicateSet { tcx: tcx, set: FnvHashSet() }
+ PredicateSet { tcx: tcx, set: FxHashSet() }
}
fn insert(&mut self, pred: &ty::Predicate<'tcx>) -> bool {
pub struct SupertraitDefIds<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
stack: Vec<DefId>,
- visited: FnvHashSet<DefId>,
+ visited: FxHashSet<DefId>,
}
pub fn supertrait_def_ids<'cx, 'gcx, 'tcx>(tcx: TyCtxt<'cx, 'gcx, 'tcx>,
use hir::def_id::{DefId};
use ty::{self, Ty, TyCtxt};
use util::common::MemoizationMap;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use std::fmt;
use std::ops;
impl<'a, 'tcx> ty::TyS<'tcx> {
pub fn type_contents(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> TypeContents {
- return tcx.tc_cache.memoize(self, || tc_ty(tcx, self, &mut FnvHashMap()));
+ return tcx.tc_cache.memoize(self, || tc_ty(tcx, self, &mut FxHashMap()));
fn tc_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
ty: Ty<'tcx>,
- cache: &mut FnvHashMap<Ty<'tcx>, TypeContents>) -> TypeContents
+ cache: &mut FxHashMap<Ty<'tcx>, TypeContents>) -> TypeContents
{
// Subtle: Note that we are *not* using tcx.tc_cache here but rather a
// private cache for this walk. This is needed in the case of cyclic
use ty::maps;
use util::common::MemoizationMap;
use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet};
-use util::nodemap::{FnvHashMap, FnvHashSet};
+use util::nodemap::{FxHashMap, FxHashSet};
use rustc_data_structures::accumulate_vec::AccumulateVec;
use arena::TypedArena;
/// Specifically use a speedy hash algorithm for these hash sets,
/// they're accessed quite often.
- type_: RefCell<FnvHashSet<Interned<'tcx, TyS<'tcx>>>>,
- type_list: RefCell<FnvHashSet<Interned<'tcx, Slice<Ty<'tcx>>>>>,
- substs: RefCell<FnvHashSet<Interned<'tcx, Substs<'tcx>>>>,
- bare_fn: RefCell<FnvHashSet<Interned<'tcx, BareFnTy<'tcx>>>>,
- region: RefCell<FnvHashSet<Interned<'tcx, Region>>>,
- stability: RefCell<FnvHashSet<&'tcx attr::Stability>>,
- layout: RefCell<FnvHashSet<&'tcx Layout>>,
+ type_: RefCell<FxHashSet<Interned<'tcx, TyS<'tcx>>>>,
+ type_list: RefCell<FxHashSet<Interned<'tcx, Slice<Ty<'tcx>>>>>,
+ substs: RefCell<FxHashSet<Interned<'tcx, Substs<'tcx>>>>,
+ bare_fn: RefCell<FxHashSet<Interned<'tcx, BareFnTy<'tcx>>>>,
+ region: RefCell<FxHashSet<Interned<'tcx, Region>>>,
+ stability: RefCell<FxHashSet<&'tcx attr::Stability>>,
+ layout: RefCell<FxHashSet<&'tcx Layout>>,
}
impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> {
fn new(arenas: &'tcx CtxtArenas<'tcx>) -> CtxtInterners<'tcx> {
CtxtInterners {
arenas: arenas,
- type_: RefCell::new(FnvHashSet()),
- type_list: RefCell::new(FnvHashSet()),
- substs: RefCell::new(FnvHashSet()),
- bare_fn: RefCell::new(FnvHashSet()),
- region: RefCell::new(FnvHashSet()),
- stability: RefCell::new(FnvHashSet()),
- layout: RefCell::new(FnvHashSet())
+ type_: RefCell::new(FxHashSet()),
+ type_list: RefCell::new(FxHashSet()),
+ substs: RefCell::new(FxHashSet()),
+ bare_fn: RefCell::new(FxHashSet()),
+ region: RefCell::new(FxHashSet()),
+ stability: RefCell::new(FxHashSet()),
+ layout: RefCell::new(FxHashSet())
}
}
impl<'a, 'gcx, 'tcx> Tables<'tcx> {
pub fn empty() -> Tables<'tcx> {
Tables {
- node_types: FnvHashMap(),
+ node_types: FxHashMap(),
item_substs: NodeMap(),
adjustments: NodeMap(),
- method_map: FnvHashMap(),
- upvar_capture_map: FnvHashMap(),
+ method_map: FxHashMap(),
+ upvar_capture_map: FxHashMap(),
closure_tys: DefIdMap(),
closure_kinds: DefIdMap(),
liberated_fn_sigs: NodeMap(),
pub tcache: RefCell<DepTrackingMap<maps::Tcache<'tcx>>>,
// Internal cache for metadata decoding. No need to track deps on this.
- pub rcache: RefCell<FnvHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
+ pub rcache: RefCell<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
// Cache for the type-contents routine. FIXME -- track deps?
- pub tc_cache: RefCell<FnvHashMap<Ty<'tcx>, ty::contents::TypeContents>>,
+ pub tc_cache: RefCell<FxHashMap<Ty<'tcx>, ty::contents::TypeContents>>,
// FIXME no dep tracking, but we should be able to remove this
pub ty_param_defs: RefCell<NodeMap<ty::TypeParameterDef<'tcx>>>,
// FIXME dep tracking -- should be harmless enough
- pub normalized_cache: RefCell<FnvHashMap<Ty<'tcx>, Ty<'tcx>>>,
+ pub normalized_cache: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
pub lang_items: middle::lang_items::LanguageItems,
pub data_layout: TargetDataLayout,
/// Cache for layouts computed from types.
- pub layout_cache: RefCell<FnvHashMap<Ty<'tcx>, &'tcx Layout>>,
+ pub layout_cache: RefCell<FxHashMap<Ty<'tcx>, &'tcx Layout>>,
/// Used to prevent layout from recursing too deeply.
pub layout_depth: Cell<usize>,
types: common_types,
named_region_map: named_region_map,
region_maps: region_maps,
- free_region_maps: RefCell::new(FnvHashMap()),
+ free_region_maps: RefCell::new(FxHashMap()),
item_variance_map: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
variance_computed: Cell::new(false),
sess: s,
freevars: RefCell::new(freevars),
maybe_unused_trait_imports: maybe_unused_trait_imports,
tcache: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- rcache: RefCell::new(FnvHashMap()),
- tc_cache: RefCell::new(FnvHashMap()),
+ rcache: RefCell::new(FxHashMap()),
+ tc_cache: RefCell::new(FxHashMap()),
impl_or_trait_items: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
impl_or_trait_item_def_ids: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
trait_items_cache: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
ty_param_defs: RefCell::new(NodeMap()),
- normalized_cache: RefCell::new(FnvHashMap()),
+ normalized_cache: RefCell::new(FxHashMap()),
lang_items: lang_items,
inherent_impls: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
used_unsafe: RefCell::new(NodeSet()),
fragment_infos: RefCell::new(DefIdMap()),
crate_name: token::intern_and_get_ident(crate_name),
data_layout: data_layout,
- layout_cache: RefCell::new(FnvHashMap()),
+ layout_cache: RefCell::new(FxHashMap()),
layout_depth: Cell::new(0),
derive_macros: RefCell::new(NodeMap()),
}, f)
use ty::{self, Binder, Ty, TyCtxt, TypeFlags};
use std::fmt;
-use util::nodemap::{FnvHashMap, FnvHashSet};
+use util::nodemap::{FxHashMap, FxHashSet};
/// The TypeFoldable trait is implemented for every type that can be folded.
/// Basically, every type that has a corresponding method in TypeFolder.
/// whether any late-bound regions were skipped
pub fn collect_regions<T>(self,
value: &T,
- region_set: &mut FnvHashSet<&'tcx ty::Region>)
+ region_set: &mut FxHashSet<&'tcx ty::Region>)
-> bool
where T : TypeFoldable<'tcx>
{
tcx: TyCtxt<'a, 'gcx, 'tcx>,
current_depth: u32,
fld_r: &'a mut (FnMut(ty::BoundRegion) -> &'tcx ty::Region + 'a),
- map: FnvHashMap<ty::BoundRegion, &'tcx ty::Region>
+ map: FxHashMap<ty::BoundRegion, &'tcx ty::Region>
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
pub fn replace_late_bound_regions<T,F>(self,
value: &Binder<T>,
mut f: F)
- -> (T, FnvHashMap<ty::BoundRegion, &'tcx ty::Region>)
+ -> (T, FxHashMap<ty::BoundRegion, &'tcx ty::Region>)
where F : FnMut(ty::BoundRegion) -> &'tcx ty::Region,
T : TypeFoldable<'tcx>,
{
/// variables and equate `value` with something else, those
/// variables will also be equated.
pub fn collect_constrained_late_bound_regions<T>(&self, value: &Binder<T>)
- -> FnvHashSet<ty::BoundRegion>
+ -> FxHashSet<ty::BoundRegion>
where T : TypeFoldable<'tcx>
{
self.collect_late_bound_regions(value, true)
/// Returns a set of all late-bound regions that appear in `value` anywhere.
pub fn collect_referenced_late_bound_regions<T>(&self, value: &Binder<T>)
- -> FnvHashSet<ty::BoundRegion>
+ -> FxHashSet<ty::BoundRegion>
where T : TypeFoldable<'tcx>
{
self.collect_late_bound_regions(value, false)
}
fn collect_late_bound_regions<T>(&self, value: &Binder<T>, just_constraint: bool)
- -> FnvHashSet<ty::BoundRegion>
+ -> FxHashSet<ty::BoundRegion>
where T : TypeFoldable<'tcx>
{
let mut collector = LateBoundRegionsCollector::new(just_constraint);
tcx: tcx,
current_depth: 1,
fld_r: fld_r,
- map: FnvHashMap()
+ map: FxHashMap()
}
}
}
/// Collects all the late-bound regions it finds into a hash set.
struct LateBoundRegionsCollector {
current_depth: u32,
- regions: FnvHashSet<ty::BoundRegion>,
+ regions: FxHashSet<ty::BoundRegion>,
just_constrained: bool,
}
fn new(just_constrained: bool) -> Self {
LateBoundRegionsCollector {
current_depth: 1,
- regions: FnvHashSet(),
+ regions: FxHashSet(),
just_constrained: just_constrained,
}
}
use ty::walk::TypeWalker;
use util::common::MemoizationMap;
use util::nodemap::NodeSet;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use serialize::{self, Encodable, Encoder};
use std::borrow::Cow;
// maps from an expression id that corresponds to a method call to the details
// of the method to be invoked
-pub type MethodMap<'tcx> = FnvHashMap<MethodCall, MethodCallee<'tcx>>;
+pub type MethodMap<'tcx> = FxHashMap<MethodCall, MethodCallee<'tcx>>;
// Contains information needed to resolve types and (in the future) look up
// the types of AST nodes.
pub region: &'tcx ty::Region,
}
-pub type UpvarCaptureMap<'tcx> = FnvHashMap<UpvarId, UpvarCapture<'tcx>>;
+pub type UpvarCaptureMap<'tcx> = FxHashMap<UpvarId, UpvarCapture<'tcx>>;
#[derive(Copy, Clone)]
pub struct ClosureUpvar<'tcx> {
pub free_id_outlive: CodeExtent,
/// A cache for `moves_by_default`.
- pub is_copy_cache: RefCell<FnvHashMap<Ty<'tcx>, bool>>,
+ pub is_copy_cache: RefCell<FxHashMap<Ty<'tcx>, bool>>,
/// A cache for `type_is_sized`
- pub is_sized_cache: RefCell<FnvHashMap<Ty<'tcx>, bool>>,
+ pub is_sized_cache: RefCell<FxHashMap<Ty<'tcx>, bool>>,
}
impl<'a, 'tcx> ParameterEnvironment<'tcx> {
implicit_region_bound: self.implicit_region_bound,
caller_bounds: caller_bounds,
free_id_outlive: self.free_id_outlive,
- is_copy_cache: RefCell::new(FnvHashMap()),
- is_sized_cache: RefCell::new(FnvHashMap()),
+ is_copy_cache: RefCell::new(FxHashMap()),
+ is_sized_cache: RefCell::new(FxHashMap()),
}
}
caller_bounds: Vec::new(),
implicit_region_bound: self.mk_region(ty::ReEmpty),
free_id_outlive: free_id_outlive,
- is_copy_cache: RefCell::new(FnvHashMap()),
- is_sized_cache: RefCell::new(FnvHashMap()),
+ is_copy_cache: RefCell::new(FxHashMap()),
+ is_sized_cache: RefCell::new(FxHashMap()),
}
}
implicit_region_bound: tcx.mk_region(ty::ReScope(free_id_outlive)),
caller_bounds: predicates,
free_id_outlive: free_id_outlive,
- is_copy_cache: RefCell::new(FnvHashMap()),
- is_sized_cache: RefCell::new(FnvHashMap()),
+ is_copy_cache: RefCell::new(FxHashMap()),
+ is_sized_cache: RefCell::new(FxHashMap()),
};
let cause = traits::ObligationCause::misc(span, free_id_outlive.node_id(&self.region_maps));
use ty::{Ty, TyCtxt, TraitRef};
use std::cell::{Cell, RefCell};
use hir;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
/// As `TypeScheme` but for a trait ref.
pub struct TraitDef<'tcx> {
/// Impls of the trait.
nonblanket_impls: RefCell<
- FnvHashMap<fast_reject::SimplifiedType, Vec<DefId>>
+ FxHashMap<fast_reject::SimplifiedType, Vec<DefId>>
>,
/// Blanket impls associated with the trait.
unsafety: unsafety,
generics: generics,
trait_ref: trait_ref,
- nonblanket_impls: RefCell::new(FnvHashMap()),
+ nonblanket_impls: RefCell::new(FxHashMap()),
blanket_impls: RefCell::new(vec![]),
flags: Cell::new(ty::TraitFlags::NO_TRAIT_FLAGS),
specialization_graph: RefCell::new(traits::specialization_graph::Graph::new()),
use ty::fold::TypeVisitor;
use ty::layout::{Layout, LayoutError};
use ty::TypeVariants::*;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use rustc_const_math::{ConstInt, ConstIsize, ConstUsize};
fn impls_bound(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>,
param_env: &ParameterEnvironment<'tcx>,
bound: ty::BuiltinBound,
- cache: &RefCell<FnvHashMap<Ty<'tcx>, bool>>,
+ cache: &RefCell<FxHashMap<Ty<'tcx>, bool>>,
span: Span) -> bool
{
if self.has_param_types() || self.has_self_ty() {
use hir::def_id::DefId;
use syntax::ast;
-pub use rustc_data_structures::fnv::FnvHashMap;
-pub use rustc_data_structures::fnv::FnvHashSet;
+pub use rustc_data_structures::fx::FxHashMap;
+pub use rustc_data_structures::fx::FxHashSet;
-pub type NodeMap<T> = F
nvHashMap<ast::NodeId, T>;
-pub type DefIdMap<T> = FnvHashMap<DefId, T>;
+pub type NodeMap<T> = F
xHashMap<ast::NodeId, T>;
+pub type DefIdMap<T> = FxHashMap<DefId, T>;
-pub type NodeSet = F
nvHashSet<ast::NodeId>;
-pub type DefIdSet = FnvHashSet<DefId>;
+pub type NodeSet = F
xHashSet<ast::NodeId>;
+pub type DefIdSet = FxHashSet<DefId>;
-pub fn NodeMap<T>() -> NodeMap<T> { FnvHashMap() }
-pub fn DefIdMap<T>() -> DefIdMap<T> { FnvHashMap() }
-pub fn NodeSet() -> NodeSet { FnvHashSet() }
-pub fn DefIdSet() -> DefIdSet { FnvHashSet() }
+pub fn NodeMap<T>() -> NodeMap<T> { FxHashMap() }
+pub fn DefIdMap<T>() -> DefIdMap<T> { FxHashMap() }
+pub fn NodeSet() -> NodeSet { FxHashSet() }
+pub fn DefIdSet() -> DefIdSet { FxHashSet() }
use rustc::mir::transform::{Pass, MirPass, MirSource};
use rustc::middle::const_val::ConstVal;
use rustc::middle::lang_items;
-use rustc::util::nodemap::FnvHashMap;
+use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::indexed_set::IdxSetBuf;
use rustc_data_structures::indexed_vec::Idx;
use syntax_pos::Span;
env: &env,
flow_inits: flow_inits,
flow_uninits: flow_uninits,
- drop_flags: FnvHashMap(),
+ drop_flags: FxHashMap(),
patch: MirPatch::new(mir),
}.elaborate()
};
env: &'a MoveDataParamEnv<'tcx>,
flow_inits: DataflowResults<MaybeInitializedLvals<'a, 'tcx>>,
flow_uninits: DataflowResults<MaybeUninitializedLvals<'a, 'tcx>>,
- drop_flags: FnvHashMap<MovePathIndex, Local>,
+ drop_flags: FxHashMap<MovePathIndex, Local>,
patch: MirPatch<'tcx>,
}
use rustc::ty::{self, TyCtxt, ParameterEnvironment};
use rustc::mir::*;
-use rustc::util::nodemap::FnvHashMap;
+use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::indexed_vec::{IndexVec};
use syntax::codemap::DUMMY_SP;
/// subsequent search so that it is solely relative to that
/// base-lvalue). For the remaining lookup, we map the projection
/// elem to the associated MovePathIndex.
- projections: FnvHashMap<(MovePathIndex, AbstractElem<'tcx>), MovePathIndex>
+ projections: FxHashMap<(MovePathIndex, AbstractElem<'tcx>), MovePathIndex>
}
struct MoveDataBuilder<'a, 'tcx: 'a> {
locals: mir.local_decls.indices().map(Lvalue::Local).map(|v| {
Self::new_move_path(&mut move_paths, &mut path_map, None, v)
}).collect(),
- projections: FnvHashMap(),
+ projections: FxHashMap(),
},
move_paths: move_paths,
path_map: path_map,
use rustc::middle::expr_use_visitor::MutateMode;
use rustc::middle::mem_categorization as mc;
use rustc::ty::{self, TyCtxt};
-use rustc::util::nodemap::{FnvHashMap, NodeSet};
+use rustc::util::nodemap::{FxHashMap, NodeSet};
use std::cell::RefCell;
use std::rc::Rc;
pub paths: RefCell<Vec<MovePath<'tcx>>>,
/// Cache of loan path to move path index, for easy lookup.
- pub path_map: RefCell<FnvHashMap<Rc<LoanPath<'tcx>>, MovePathIndex>>,
+ pub path_map: RefCell<FxHashMap<Rc<LoanPath<'tcx>>, MovePathIndex>>,
/// Each move or uninitialized variable gets an entry here.
pub moves: RefCell<Vec<Move>>,
pub fn new() -> MoveData<'tcx> {
MoveData {
paths: RefCell::new(Vec::new()),
- path_map: RefCell::new(FnvHashMap()),
+ path_map: RefCell::new(FxHashMap()),
moves: RefCell::new(Vec::new()),
path_assignments: RefCell::new(Vec::new()),
var_assignments: RefCell::new(Vec::new()),
use rustc_const_math::ConstInt;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::Idx;
use pattern::{FieldPattern, Pattern, PatternKind};
/// associated types to get field types.
pub wild_pattern: &'a Pattern<'tcx>,
pub pattern_arena: &'a TypedArena<Pattern<'tcx>>,
- pub byte_array_map: FnvHashMap<*const Pattern<'tcx>, Vec<&'a Pattern<'tcx>>>,
+ pub byte_array_map: FxHashMap<*const Pattern<'tcx>, Vec<&'a Pattern<'tcx>>>,
}
impl<'a, 'tcx> MatchCheckCtxt<'a, 'tcx> {
tcx: tcx,
wild_pattern: &wild_pattern,
pattern_arena: &pattern_arena,
- byte_array_map: FnvHashMap(),
+ byte_array_map: FxHashMap(),
})
}
pub mod transitive_relation;
pub mod unify;
pub mod fnv;
+pub mod fx;
pub mod tuple_slice;
pub mod veccell;
pub mod control_flow_graph;
//! in the first place). See README.md for a general overview of how
//! to use this class.
-use fnv::{FnvHashMap, FnvHashSet};
+use fx::{FxHashMap, FxHashSet};
use std::cell::Cell;
use std::collections::hash_map::Entry;
/// backtrace iterator (which uses `split_at`).
nodes: Vec<Node<O>>,
/// A cache of predicates that have been successfully completed.
- done_cache: FnvHashSet<O::Predicate>,
+ done_cache: FxHashSet<O::Predicate>,
/// An cache of the nodes in `nodes`, indexed by predicate.
- waiting_cache: FnvHashMap<O::Predicate, NodeIndex>,
+ waiting_cache: FxHashMap<O::Predicate, NodeIndex>,
/// A list of the obligations added in snapshots, to allow
/// for their removal.
cache_list: Vec<O::Predicate>,
ObligationForest {
nodes: vec![],
snapshots: vec![],
- done_cache: FnvHashSet(),
- waiting_cache: FnvHashMap(),
+ done_cache: FxHashSet(),
+ waiting_cache: FxHashMap(),
cache_list: vec![],
scratch: Some(vec![]),
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use fnv::FnvHashMap;
+use fx::FxHashMap;
use std::hash::Hash;
use std::ops;
use std::mem;
pub struct SnapshotMap<K, V>
where K: Hash + Clone + Eq
{
- map: FnvHashMap<K, V>,
+ map: FxHashMap<K, V>,
undo_log: Vec<UndoLog<K, V>>,
}
{
pub fn new() -> Self {
SnapshotMap {
- map: FnvHashMap(),
+ map: FxHashMap(),
undo_log: vec![],
}
}
use rustc::dep_graph::debug::{DepNodeFilter, EdgeFilter};
use rustc::hir::def_id::DefId;
use rustc::ty::TyCtxt;
-use rustc_data_structures::fnv::FnvHashSet;
+use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::graph::{Direction, INCOMING, OUTGOING, NodeIndex};
use rustc::hir;
use rustc::hir::intravisit::Visitor;
}
}
-pub struct GraphvizDepGraph<'q>(FnvHashSet<&'q DepNode<DefId>>,
+pub struct GraphvizDepGraph<'q>(FxHashSet<&'q DepNode<DefId>>,
Vec<(&'q DepNode<DefId>, &'q DepNode<DefId>)>);
impl<'a, 'tcx, 'q> dot::GraphWalk<'a> for GraphvizDepGraph<'q> {
// filter) or the set of nodes whose labels contain all of those
// substrings.
fn node_set<'q>(query: &'q DepGraphQuery<DefId>, filter: &DepNodeFilter)
- -> Option<FnvHashSet<&'q DepNode<DefId>>>
+ -> Option<FxHashSet<&'q DepNode<DefId>>>
{
debug!("node_set(filter={:?})", filter);
}
fn filter_nodes<'q>(query: &'q DepGraphQuery<DefId>,
- sources: &Option<FnvHashSet<&'q DepNode<DefId>>>,
- targets: &Option<FnvHashSet<&'q DepNode<DefId>>>)
- -> FnvHashSet<&'q DepNode<DefId>>
+ sources: &Option<FxHashSet<&'q DepNode<DefId>>>,
+ targets: &Option<FxHashSet<&'q DepNode<DefId>>>)
+ -> FxHashSet<&'q DepNode<DefId>>
{
if let &Some(ref sources) = sources {
if let &Some(ref targets) = targets {
}
fn walk_nodes<'q>(query: &'q DepGraphQuery<DefId>,
- starts: &FnvHashSet<&'q DepNode<DefId>>,
+ starts: &FxHashSet<&'q DepNode<DefId>>,
direction: Direction)
- -> FnvHashSet<&'q DepNode<DefId>>
+ -> FxHashSet<&'q DepNode<DefId>>
{
- let mut set = FnvHashSet();
+ let mut set = FxHashSet();
for &start in starts {
debug!("walk_nodes: start={:?} outgoing?={:?}", start, direction == OUTGOING);
if set.insert(start) {
}
fn walk_between<'q>(query: &'q DepGraphQuery<DefId>,
- sources: &FnvHashSet<&'q DepNode<DefId>>,
- targets: &FnvHashSet<&'q DepNode<DefId>>)
- -> FnvHashSet<&'q DepNode<DefId>>
+ sources: &FxHashSet<&'q DepNode<DefId>>,
+ targets: &FxHashSet<&'q DepNode<DefId>>)
+ -> FxHashSet<&'q DepNode<DefId>>
{
// This is a bit tricky. We want to include a node only if it is:
// (a) reachable from a source and (b) will reach a target. And we
}
fn filter_edges<'q>(query: &'q DepGraphQuery<DefId>,
- nodes: &FnvHashSet<&'q DepNode<DefId>>)
+ nodes: &FxHashSet<&'q DepNode<DefId>>)
-> Vec<(&'q DepNode<DefId>, &'q DepNode<DefId>)>
{
query.edges()
use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
use rustc::hir::intravisit as visit;
use rustc::ty::TyCtxt;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc::util::common::record_time;
use rustc::session::config::DebugInfoLevel::NoDebugInfo;
pub mod hasher;
pub struct IncrementalHashesMap {
- hashes: FnvHashMap<DepNode<DefId>, Fingerprint>,
+ hashes: FxHashMap<DepNode<DefId>, Fingerprint>,
// These are the metadata hashes for the current crate as they were stored
// during the last compilation session. They are only loaded if
// -Z query-dep-graph was specified and are needed for auto-tests using
// the #[rustc_metadata_dirty] and #[rustc_metadata_clean] attributes to
// check whether some metadata hash has changed in between two revisions.
- pub prev_metadata_hashes: RefCell<FnvHashMap<DefId, Fingerprint>>,
+ pub prev_metadata_hashes: RefCell<FxHashMap<DefId, Fingerprint>>,
}
impl IncrementalHashesMap {
pub fn new() -> IncrementalHashesMap {
IncrementalHashesMap {
- hashes: FnvHashMap(),
- prev_metadata_hashes: RefCell::new(FnvHashMap()),
+ hashes: FxHashMap(),
+ prev_metadata_hashes: RefCell::new(FxHashMap()),
}
}
use rustc::dep_graph::{DepNode, WorkProduct, WorkProductId};
use rustc::hir::def_id::DefIndex;
use std::sync::Arc;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use ich::Fingerprint;
use super::directory::DefPathIndex;
/// is only populated if -Z query-dep-graph is specified. It will be
/// empty otherwise. Importing crates are perfectly happy with just having
/// the DefIndex.
- pub index_map: FnvHashMap<DefIndex, DefPathIndex>
+ pub index_map: FxHashMap<DefIndex, DefPathIndex>
}
/// The hash for some metadata that (when saving) will be exported
use rustc::hir::def_id::DefId;
use rustc::hir::intravisit::Visitor;
use syntax::ast::{self, Attribute, NestedMetaItem};
-use rustc_data_structures::fnv::{FnvHashSet, FnvHashMap};
+use rustc_data_structures::fx::{FxHashSet, FxHashMap};
use syntax::parse::token::InternedString;
use syntax_pos::Span;
use rustc::ty::TyCtxt;
}
let _ignore = tcx.dep_graph.in_ignore();
- let dirty_inputs: FnvHashSet<DepNode<DefId>> =
+ let dirty_inputs: FxHashSet<DepNode<DefId>> =
dirty_inputs.iter()
.filter_map(|d| retraced.map(d))
.collect();
pub struct DirtyCleanVisitor<'a, 'tcx:'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
query: &'a DepGraphQuery<DefId>,
- dirty_inputs: FnvHashSet<DepNode<DefId>>,
+ dirty_inputs: FxHashSet<DepNode<DefId>>,
}
impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
}
pub fn check_dirty_clean_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- prev_metadata_hashes: &FnvHashMap<DefId, Fingerprint>,
- current_metadata_hashes: &FnvHashMap<DefId, Fingerprint>) {
+ prev_metadata_hashes: &FxHashMap<DefId, Fingerprint>,
+ current_metadata_hashes: &FxHashMap<DefId, Fingerprint>) {
if !tcx.sess.opts.debugging_opts.query_dep_graph {
return;
}
pub struct DirtyCleanMetadataVisitor<'a, 'tcx:'a, 'm> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- prev_metadata_hashes: &'m FnvHashMap<DefId, Fingerprint>,
- current_metadata_hashes: &'m FnvHashMap<DefId, Fingerprint>,
+ prev_metadata_hashes: &'m FxHashMap<DefId, Fingerprint>,
+ current_metadata_hashes: &'m FxHashMap<DefId, Fingerprint>,
}
impl<'a, 'tcx, 'm> Visitor<'tcx> for DirtyCleanMetadataVisitor<'a, 'tcx, 'm> {
use rustc::ty::TyCtxt;
use rustc::util::fs as fs_util;
use rustc_data_structures::flock;
-use rustc_data_structures::fnv::{FnvHashSet, FnvHashMap};
+use rustc_data_structures::fx::{FxHashSet, FxHashMap};
use std::ffi::OsString;
use std::fs as std_fs;
debug!("crate-dir: {}", crate_dir.display());
try!(create_dir(tcx.sess, &crate_dir, "crate"));
- let mut source_directories_already_tried = FnvHashSet();
+ let mut source_directories_already_tried = FxHashSet();
loop {
// Generate a session directory of the form:
/// Find the most recent published session directory that is not in the
/// ignore-list.
fn find_source_directory(crate_dir: &Path,
- source_directories_already_tried: &F
nvHashSet<PathBuf>)
+ source_directories_already_tried: &F
xHashSet<PathBuf>)
-> Option<PathBuf> {
let iter = crate_dir.read_dir()
.unwrap() // FIXME
}
fn find_source_directory_in_iter<I>(iter: I,
- source_directories_already_tried: &F
nvHashSet<PathBuf>)
+ source_directories_already_tried: &F
xHashSet<PathBuf>)
-> Option<PathBuf>
where I: Iterator<Item=PathBuf>
{
// First do a pass over the crate directory, collecting lock files and
// session directories
- let mut session_directories = FnvHashSet();
- let mut lock_files = FnvHashSet();
+ let mut session_directories = FxHashSet();
+ let mut lock_files = FxHashSet();
for dir_entry in try!(crate_directory.read_dir()) {
let dir_entry = match dir_entry {
}
// Now map from lock files to session directories
- let lock_file_to_session_dir: FnvHashMap<String, Option<String>> =
+ let lock_file_to_session_dir: FxHashMap<String, Option<String>> =
lock_files.into_iter()
.map(|lock_file_name| {
assert!(lock_file_name.ends_with(LOCK_FILE_EXT));
}
// Filter out `None` directories
- let lock_file_to_session_dir: FnvHashMap<String, String> =
+ let lock_file_to_session_dir: FxHashMap<String, String> =
lock_file_to_session_dir.into_iter()
.filter_map(|(lock_file_name, directory_name)| {
directory_name.map(|n| (lock_file_name, n))
}
fn all_except_most_recent(deletion_candidates: Vec<(SystemTime, PathBuf, Option<flock::Lock>)>)
- -> F
nvHashMap<PathBuf, Option<flock::Lock>> {
+ -> F
xHashMap<PathBuf, Option<flock::Lock>> {
let most_recent = deletion_candidates.iter()
.map(|&(timestamp, ..)| timestamp)
.max();
.map(|(_, path, lock)| (path, lock))
.collect()
} else {
- FnvHashMap()
+ FxHashMap()
}
}
(UNIX_EPOCH + Duration::new(5, 0), PathBuf::from("5"), None),
(UNIX_EPOCH + Duration::new(3, 0), PathBuf::from("3"), None),
(UNIX_EPOCH + Duration::new(2, 0), PathBuf::from("2"), None),
- ]).keys().cloned().collect::<F
nvHashSet<PathBuf>>(),
+ ]).keys().cloned().collect::<F
xHashSet<PathBuf>>(),
vec![
PathBuf::from("1"),
PathBuf::from("2"),
PathBuf::from("3"),
PathBuf::from("4"),
- ].into_iter().collect::<F
nvHashSet<PathBuf>>()
+ ].into_iter().collect::<F
xHashSet<PathBuf>>()
);
assert_eq!(all_except_most_recent(
vec![
- ]).keys().cloned().collect::<F
nvHashSet<PathBuf>>(),
- FnvHashSet()
+ ]).keys().cloned().collect::<F
xHashSet<PathBuf>>(),
+ FxHashSet()
);
}
#[test]
fn test_find_source_directory_in_iter() {
- let already_visited = FnvHashSet();
+ let already_visited = FxHashSet();
// Find newest
assert_eq!(find_source_directory_in_iter(
use rustc::hir::def_id::{CrateNum, DefId};
use rustc::hir::svh::Svh;
use rustc::ty::TyCtxt;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::flock;
use rustc_serialize::Decodable;
use rustc_serialize::opaque::Decoder;
pub struct HashContext<'a, 'tcx: 'a> {
pub tcx: TyCtxt<'a, 'tcx, 'tcx>,
incremental_hashes_map: &'a IncrementalHashesMap,
- item_metadata_hashes: FnvHashMap<DefId, Fingerprint>,
- crate_hashes: FnvHashMap<CrateNum, Svh>,
+ item_metadata_hashes: FxHashMap<DefId, Fingerprint>,
+ crate_hashes: FxHashMap<CrateNum, Svh>,
}
impl<'a, 'tcx> HashContext<'a, 'tcx> {
HashContext {
tcx: tcx,
incremental_hashes_map: incremental_hashes_map,
- item_metadata_hashes: FnvHashMap(),
- crate_hashes: FnvHashMap(),
+ item_metadata_hashes: FxHashMap(),
+ crate_hashes: FxHashMap(),
}
}
use rustc::hir::svh::Svh;
use rustc::session::Session;
use rustc::ty::TyCtxt;
-use rustc_data_structures::fnv::{FnvHashSet, FnvHashMap};
+use rustc_data_structures::fx::{FxHashSet, FxHashMap};
use rustc_serialize::Decodable as RustcDecodable;
use rustc_serialize::opaque::Decoder;
use std::fs;
use super::fs::*;
use super::file_format;
-pub type DirtyNodes = FnvHashSet<DepNode<DefPathIndex>>;
+pub type DirtyNodes = FxHashSet<DepNode<DefPathIndex>>;
/// If we are in incremental mode, and a previous dep-graph exists,
/// then load up those nodes/edges that are still valid into the
// Compute which work-products have an input that has changed or
// been removed. Put the dirty ones into a set.
- let mut dirty_target_nodes = FnvHashSet();
+ let mut dirty_target_nodes = FxHashSet();
for &(raw_source_node, ref target_node) in &retraced_edges {
if dirty_raw_source_nodes.contains(raw_source_node) {
if !dirty_target_nodes.contains(target_node) {
retraced: &RetracedDefIdDirectory)
-> DirtyNodes {
let mut hcx = HashContext::new(tcx, incremental_hashes_map);
- let mut dirty_nodes = FnvHashSet();
+ let mut dirty_nodes = FxHashSet();
for hash in serialized_hashes {
if let Some(dep_node) = retraced.map(&hash.dep_node) {
/// otherwise no longer applicable.
fn reconcile_work_products<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
work_products: Vec<SerializedWorkProduct>,
- dirty_target_nodes: &FnvHashSet<DepNode<DefId>>) {
+ dirty_target_nodes: &FxHashSet<DepNode<DefId>>) {
debug!("reconcile_work_products({:?})", work_products);
for swp in work_products {
if dirty_target_nodes.contains(&DepNode::WorkProduct(swp.id.clone())) {
fn load_prev_metadata_hashes(tcx: TyCtxt,
retraced: &RetracedDefIdDirectory,
- output: &mut FnvHashMap<DefId, Fingerprint>) {
+ output: &mut FxHashMap<DefId, Fingerprint>) {
if !tcx.sess.opts.debugging_opts.query_dep_graph {
return
}
use rustc::dep_graph::{DepGraphQuery, DepNode};
use rustc::hir::def_id::DefId;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::graph::{DepthFirstTraversal, INCOMING, NodeIndex};
use super::hash::*;
// nodes.
// - Values: transitive predecessors of the key that are hashable
// (e.g., HIR nodes, input meta-data nodes)
- pub inputs: FnvHashMap<&'query DepNode<DefId>, Vec<&'query DepNode<DefId>>>,
+ pub inputs: FxHashMap<&'query DepNode<DefId>, Vec<&'query DepNode<DefId>>>,
// - Keys: some hashable node
// - Values: the hash thereof
- pub hashes: FnvHashMap<&'query DepNode<DefId>, Fingerprint>,
+ pub hashes: FxHashMap<&'query DepNode<DefId>, Fingerprint>,
}
impl<'q> Predecessors<'q> {
let all_nodes = query.graph.all_nodes();
let tcx = hcx.tcx;
- let inputs: FnvHashMap<_, _> = all_nodes.iter()
+ let inputs: FxHashMap<_, _> = all_nodes.iter()
.enumerate()
.filter(|&(_, node)| match node.data {
DepNode::WorkProduct(_) => true,
})
.collect();
- let mut hashes = FnvHashMap();
+ let mut hashes = FxHashMap();
for input in inputs.values().flat_map(|v| v.iter().cloned()) {
hashes.entry(input)
.or_insert_with(|| hcx.hash(input).unwrap());
use rustc::hir::svh::Svh;
use rustc::session::Session;
use rustc::ty::TyCtxt;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_serialize::Encodable as RustcEncodable;
use rustc_serialize::opaque::Encoder;
use std::hash::Hash;
let query = tcx.dep_graph.query();
let mut hcx = HashContext::new(tcx, incremental_hashes_map);
let preds = Predecessors::new(&query, &mut hcx);
- let mut current_metadata_hashes = FnvHashMap();
+ let mut current_metadata_hashes = FxHashMap();
// IMPORTANT: We are saving the metadata hashes *before* the dep-graph,
// since metadata-encoding might add new entries to the
svh: Svh,
preds: &Predecessors,
builder: &mut DefIdDirectoryBuilder,
- current_metadata_hashes: &mut FnvHashMap<DefId, Fingerprint>,
+ current_metadata_hashes: &mut FxHashMap<DefId, Fingerprint>,
encoder: &mut Encoder)
-> io::Result<()> {
// For each `MetaData(X)` node where `X` is local, accumulate a
// (I initially wrote this with an iterator, but it seemed harder to read.)
let mut serialized_hashes = SerializedMetadataHashes {
hashes: vec![],
- index_map: FnvHashMap()
+ index_map: FxHashMap()
};
- let mut def_id_hashes = FnvHashMap();
+ let mut def_id_hashes = FxHashMap();
for (&target, sources) in &preds.inputs {
let def_id = match *target {
use middle::const_val::ConstVal;
use rustc_const_eval::eval_const_expr_partial;
use rustc_const_eval::EvalHint::ExprTypeChecked;
-use util::nodemap::FnvHashSet;
+use util::nodemap::FxHashSet;
use lint::{LateContext, LintContext, LintArray};
use lint::{LintPass, LateLintPass};
impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
/// Check if the given type is "ffi-safe" (has a stable, well-defined
/// representation which can be exported to C code).
- fn check_type_for_ffi(&self, cache: &mut FnvHashSet<Ty<'tcx>>, ty: Ty<'tcx>) -> FfiResult {
+ fn check_type_for_ffi(&self, cache: &mut FxHashSet<Ty<'tcx>>, ty: Ty<'tcx>) -> FfiResult {
use self::FfiResult::*;
let cx = self.cx.tcx;
// any generic types right now:
let ty = self.cx.tcx.normalize_associated_type(&ty);
- match self.check_type_for_ffi(&mut FnvHashSet(), ty) {
+ match self.check_type_for_ffi(&mut FxHashSet(), ty) {
FfiResult::FfiSafe => {}
FfiResult::FfiUnsafe(s) => {
self.cx.span_lint(IMPROPER_CTYPES, sp, s);
use rustc::hir::pat_util;
use rustc::ty;
use rustc::ty::adjustment;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use lint::{LateContext, EarlyContext, LintContext, LintArray};
use lint::{LintPass, EarlyLintPass, LateLintPass};
// collect all mutable pattern and group their NodeIDs by their Identifier to
// avoid false warnings in match arms with multiple patterns
- let mut mutables = FnvHashMap();
+ let mut mutables = FxHashMap();
for p in pats {
pat_util::pat_bindings(p, |mode, id, _, path1| {
let name = path1.node;
use rustc::session::search_paths::PathKind;
use rustc::middle;
use rustc::middle::cstore::{CrateStore, validate_crate_name, ExternCrate};
-use rustc::util::nodemap::{FnvHashMap, FnvHashSet};
+use rustc::util::nodemap::{FxHashMap, FxHashSet};
use rustc::hir::map::Definitions;
use std::cell::{RefCell, Cell};
pub sess: &'a Session,
cstore: &'a CStore,
next_crate_num: CrateNum,
- foreign_item_map: F
nvHashMap<String, Vec<ast::NodeId>>,
+ foreign_item_map: F
xHashMap<String, Vec<ast::NodeId>>,
local_crate_name: String,
}
sess: sess,
cstore: cstore,
next_crate_num: cstore.next_crate_num(),
- foreign_item_map: FnvHashMap(),
+ foreign_item_map: FxHashMap(),
local_crate_name: local_crate_name.to_owned(),
}
}
fn update_extern_crate(&mut self,
cnum: CrateNum,
mut extern_crate: ExternCrate,
- visited: &mut FnvHashSet<(CrateNum, bool)>)
+ visited: &mut FxHashSet<(CrateNum, bool)>)
{
if !visited.insert((cnum, extern_crate.direct)) { return }
// The map from crate numbers in the crate we're resolving to local crate
// numbers
let deps = crate_root.crate_deps.decode(metadata);
- let map: FnvHashMap<_, _> = deps.enumerate().map(|(crate_num, dep)| {
+ let map: FxHashMap<_, _> = deps.enumerate().map(|(crate_num, dep)| {
debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash);
let (local_cnum, ..) = self.resolve_crate(root,
&dep.name.as_str(),
let extern_crate =
ExternCrate { def_id: def_id, span: item.span, direct: true, path_len: len };
- self.update_extern_crate(cnum, extern_crate, &mut FnvHashSet());
+ self.update_extern_crate(cnum, extern_crate, &mut FxHashSet());
self.cstore.add_extern_mod_stmt_cnum(info.id, cnum);
loaded_macros
use rustc::middle::cstore::ExternCrate;
use rustc_back::PanicStrategy;
use rustc_data_structures::indexed_vec::IndexVec;
-use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet, DefIdMap};
+use rustc::util::nodemap::{FxHashMap, NodeMap, NodeSet, DefIdMap};
use std::cell::{RefCell, Cell};
use std::rc::Rc;
/// hashmap, which gives the reverse mapping. This allows us to
/// quickly retrace a `DefPath`, which is needed for incremental
/// compilation support.
- pub key_map: FnvHashMap<DefKey, DefIndex>,
+ pub key_map: FxHashMap<DefKey, DefIndex>,
/// Flag if this crate is required by an rlib version of this crate, or in
/// other words whether it was explicitly linked to. An example of a crate
pub struct CStore {
pub dep_graph: DepGraph,
- metas: RefCell<FnvHashMap<CrateNum, Rc<CrateMetadata>>>,
+ metas: RefCell<FxHashMap<CrateNum, Rc<CrateMetadata>>>,
/// Map from NodeId's of local extern crate statements to crate numbers
extern_mod_crate_map: RefCell<NodeMap<CrateNum>>,
used_crate_sources: RefCell<Vec<CrateSource>>,
pub fn new(dep_graph: &DepGraph) -> CStore {
CStore {
dep_graph: dep_graph.clone(),
- metas: RefCell::new(FnvHashMap()),
- extern_mod_crate_map: RefCell::new(FnvHashMap()),
+ metas: RefCell::new(FxHashMap()),
+ extern_mod_crate_map: RefCell::new(FxHashMap()),
used_crate_sources: RefCell::new(Vec::new()),
used_libraries: RefCell::new(Vec::new()),
used_link_args: RefCell::new(Vec::new()),
statically_included_foreign_items: RefCell::new(NodeSet()),
- visible_parent_map: RefCell::new(FnvHashMap()),
- inlined_item_cache: RefCell::new(FnvHashMap()),
- defid_for_inlined_node: RefCell::new(FnvHashMap()),
+ visible_parent_map: RefCell::new(FxHashMap()),
+ inlined_item_cache: RefCell::new(FxHashMap()),
+ defid_for_inlined_node: RefCell::new(FxHashMap()),
}
}
use rustc::hir::map as hir_map;
use rustc::hir::map::{DefKey, DefPathData};
-use rustc::util::nodemap::FnvHashMap;
+use rustc::util::nodemap::FxHashMap;
use rustc::hir;
use rustc::hir::intravisit::IdRange;
/// Go through each item in the metadata and create a map from that
/// item's def-key to the item's DefIndex.
- pub fn load_key_map(&self, index: LazySeq<Index>) -> FnvHashMap<DefKey, DefIndex> {
+ pub fn load_key_map(&self, index: LazySeq<Index>) -> FxHashMap<DefKey, DefIndex> {
index.iter_enumerated(self.raw_bytes())
.map(|(index, item)| (item.decode(self).def_key.decode(self), index))
.collect()
use rustc::ty::{self, Ty, TyCtxt};
use rustc::session::config::{self, CrateTypeProcMacro};
-use rustc::util::nodemap::{FnvHashMap, NodeSet};
+use rustc::util::nodemap::{FxHashMap, NodeSet};
use rustc_serialize::{Encodable, Encoder, SpecializedEncoder, opaque};
use std::hash::Hash;
reachable: &'a NodeSet,
lazy_state: LazyState,
- type_shorthands: FnvHashMap<Ty<'tcx>, usize>,
- predicate_shorthands: FnvHashMap<ty::Predicate<'tcx>, usize>,
+ type_shorthands: FxHashMap<Ty<'tcx>, usize>,
+ predicate_shorthands: FxHashMap<ty::Predicate<'tcx>, usize>,
}
macro_rules! encoder_methods {
variant: &U,
map: M)
-> Result<(), <Self as Encoder>::Error>
- where M: for<'b> Fn(&'b mut Self) -> &'b mut FnvHashMap<T, usize>,
+ where M: for<'b> Fn(&'b mut Self) -> &'b mut FxHashMap<T, usize>,
T: Clone + Eq + Hash,
U: Encodable
{
struct ImplVisitor<'a, 'tcx: 'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- impls: FnvHashMap<DefId, Vec<DefIndex>>,
+ impls: FxHashMap<DefId, Vec<DefIndex>>,
}
impl<'a, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'tcx> {
fn encode_impls(&mut self) -> LazySeq<TraitImpls> {
let mut visitor = ImplVisitor {
tcx: self.tcx,
- impls: FnvHashMap(),
+ impls: FxHashMap(),
};
self.tcx.map.krate().visit_all_items(&mut visitor);
use rustc::session::filesearch::{FileSearch, FileMatches, FileDoesntMatch};
use rustc::session::search_paths::PathKind;
use rustc::util::common;
-use rustc::util::nodemap::FnvHashMap;
+use rustc::util::nodemap::FxHashMap;
use rustc_llvm as llvm;
use rustc_llvm::{False, ObjectFile, mk_section_iter};
let rlib_prefix = format!("lib{}", self.crate_name);
let staticlib_prefix = format!("{}{}", staticpair.0, self.crate_name);
- let mut candidates = FnvHashMap();
+ let mut candidates = FxHashMap();
let mut staticlibs = vec![];
// First, find all possible candidate rlibs and dylibs purely based on
let hash_str = hash.to_string();
let slot = candidates.entry(hash_str)
- .or_insert_with(|| (FnvHashMap(), FnvHashMap()));
+ .or_insert_with(|| (FxHashMap(), FxHashMap()));
let (ref mut rlibs, ref mut dylibs) = *slot;
fs::canonicalize(path)
.map(|p| {
// A Library candidate is created if the metadata for the set of
// libraries corresponds to the crate id and hash criteria that this
// search is being performed for.
- let mut libraries = FnvHashMap();
+ let mut libraries = FxHashMap();
for (_hash, (rlibs, dylibs)) in candidates {
let mut slot = None;
let rlib = self.extract_one(rlibs, CrateFlavor::Rlib, &mut slot);
// be read, it is assumed that the file isn't a valid rust library (no
// errors are emitted).
fn extract_one(&mut self,
- m: F
nvHashMap<PathBuf, PathKind>,
+ m: F
xHashMap<PathBuf, PathKind>,
flavor: CrateFlavor,
slot: &mut Option<(Svh, MetadataBlob)>)
-> Option<(PathBuf, PathKind)> {
// rlibs/dylibs.
let sess = self.sess;
let dylibname = self.dylibname();
- let mut rlibs = FnvHashMap();
- let mut dylibs = FnvHashMap();
+ let mut rlibs = FxHashMap();
+ let mut dylibs = FxHashMap();
{
let locs = locs.map(|l| PathBuf::from(l)).filter(|loc| {
if !loc.exists() {
use std;
use rustc_const_math::{ConstMathErr, Op};
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::Idx;
use build::{BlockAnd, BlockAndExtension, Builder};
// first process the set of fields that were provided
// (evaluating them in order given by user)
- let fields_map: FnvHashMap<_, _> =
+ let fields_map: FxHashMap<_, _> =
fields.into_iter()
.map(|f| (f.name, unpack!(block = this.as_operand(block, f.expr))))
.collect();
//! details.
use build::{BlockAnd, BlockAndExtension, Builder};
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::bitvec::BitVector;
use rustc::middle::const_val::ConstVal;
use rustc::ty::{AdtDef, Ty};
SwitchInt {
switch_ty: Ty<'tcx>,
options: Vec<ConstVal>,
- indices: FnvHashMap<ConstVal, usize>,
+ indices: FxHashMap<ConstVal, usize>,
},
// test for equality
use build::Builder;
use build::matches::{Candidate, MatchPair, Test, TestKind};
use hair::*;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::bitvec::BitVector;
use rustc::middle::const_val::ConstVal;
use rustc::ty::{self, Ty};
// these maps are empty to start; cases are
// added below in add_cases_to_switch
options: vec![],
- indices: FnvHashMap(),
+ indices: FxHashMap(),
}
}
}
candidate: &Candidate<'pat, 'tcx>,
switch_ty: Ty<'tcx>,
options: &mut Vec<ConstVal>,
- indices: &mut FnvHashMap<ConstVal, usize>)
+ indices: &mut FxHashMap<ConstVal, usize>)
-> bool
{
let match_pair = match candidate.match_pairs.iter().find(|mp| mp.lvalue == *test_lvalue) {
use rustc::mir::*;
use syntax_pos::Span;
use rustc_data_structures::indexed_vec::Idx;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
pub struct Scope<'tcx> {
/// the scope-id within the scope_auxiliary
free: Option<FreeData<'tcx>>,
/// The cache for drop chain on “normal” exit into a particular BasicBlock.
- cached_exits: FnvHashMap<(BasicBlock, CodeExtent), BasicBlock>,
+ cached_exits: FxHashMap<(BasicBlock, CodeExtent), BasicBlock>,
}
struct DropData<'tcx> {
needs_cleanup: false,
drops: vec![],
free: None,
- cached_exits: FnvHashMap()
+ cached_exits: FxHashMap()
});
self.scope_auxiliary.push(ScopeAuxiliary {
extent: extent,
use rustc::mir::*;
use rustc::mir::transform::MirSource;
use rustc::ty::TyCtxt;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::{Idx};
use std::fmt::Display;
use std::fs;
}
fn scope_entry_exit_annotations(auxiliary: Option<&ScopeAuxiliaryVec>)
- -> F
nvHashMap<Location, Vec<Annotation>>
+ -> F
xHashMap<Location, Vec<Annotation>>
{
// compute scope/entry exit annotations
- let mut annotations = FnvHashMap();
+ let mut annotations = FxHashMap();
if let Some(auxiliary) = auxiliary {
for (scope_id, auxiliary) in auxiliary.iter_enumerated() {
annotations.entry(auxiliary.dom)
block: BasicBlock,
mir: &Mir,
w: &mut Write,
- annotations: &F
nvHashMap<Location, Vec<Annotation>>)
+ annotations: &F
xHashMap<Location, Vec<Annotation>>)
-> io::Result<()> {
let data = &mir[block];
/// Returns the total number of variables printed.
fn write_scope_tree(tcx: TyCtxt,
mir: &Mir,
- scope_tree: &FnvHashMap<VisibilityScope, Vec<VisibilityScope>>,
+ scope_tree: &FxHashMap<VisibilityScope, Vec<VisibilityScope>>,
w: &mut Write,
parent: VisibilityScope,
depth: usize)
writeln!(w, " {{")?;
// construct a scope tree and write it out
- let mut scope_tree: FnvHashMap<VisibilityScope, Vec<VisibilityScope>> = FnvHashMap();
+ let mut scope_tree: FxHashMap<VisibilityScope, Vec<VisibilityScope>> = FxHashMap();
for (index, scope_data) in mir.visibility_scopes.iter().enumerate() {
if let Some(parent) = scope_data.parent_scope {
scope_tree.entry(parent)
use rustc::mir::transform::{MirPass, MirSource, Pass};
use rustc::mir::visit::{MutVisitor, Visitor};
use rustc::ty::TyCtxt;
-use rustc::util::nodemap::FnvHashSet;
+use rustc::util::nodemap::FxHashSet;
use rustc_data_structures::indexed_vec::Idx;
use std::mem;
#[derive(Default)]
struct OptimizationList {
- and_stars: FnvHashSet<Location>,
+ and_stars: FxHashSet<Location>,
}
use rustc::hir;
use rustc::hir::intravisit as hir_visit;
use rustc::util::common::to_readable_str;
-use rustc::util::nodemap::{FnvHashMap, FnvHashSet};
+use rustc::util::nodemap::{FxHashMap, FxHashSet};
use syntax::ast::{self, NodeId, AttrId};
use syntax::visit as ast_visit;
use syntax_pos::Span;
struct StatCollector<'k> {
krate: Option<&'k hir::Crate>,
- data: FnvHashMap<&'static str, NodeData>,
- seen: FnvHashSet<Id>,
+ data: FxHashMap<&'static str, NodeData>,
+ seen: FxHashSet<Id>,
}
pub fn print_hir_stats(krate: &hir::Crate) {
let mut collector = StatCollector {
krate: Some(krate),
- data: FnvHashMap(),
- seen: FnvHashSet(),
+ data: FxHashMap(),
+ seen: FxHashSet(),
};
hir_visit::walk_crate(&mut collector, krate);
collector.print("HIR STATS");
pub fn print_ast_stats(krate: &ast::Crate, title: &str) {
let mut collector = StatCollector {
krate: None,
- data: FnvHashMap(),
- seen: FnvHashSet(),
+ data: FxHashMap(),
+ seen: FxHashSet(),
};
ast_visit::walk_crate(&mut collector, krate);
collector.print(title);
use rustc::hir::def::*;
use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
use rustc::ty;
-use rustc::util::nodemap::FnvHashMap;
+use rustc::util::nodemap::FxHashMap;
use std::cell::Cell;
use std::rc::Rc;
self.invocations.insert(mark, invocation);
}
- let mut macros: FnvHashMap<_, _> = macros.into_iter().map(|mut def| {
+ let mut macros: FxHashMap<_, _> = macros.into_iter().map(|mut def| {
def.body = mark_tts(&def.body, mark);
let ext = macro_rules::compile(&self.session.parse_sess, &def);
(def.ident.name, (def, Rc::new(ext)))
use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId};
use rustc::ty;
use rustc::hir::{Freevar, FreevarMap, TraitCandidate, TraitMap, GlobMap};
-use rustc::util::nodemap::{NodeMap, NodeSet, FnvHashMap, FnvHashSet};
+use rustc::util::nodemap::{NodeMap, NodeSet, FxHashMap, FxHashSet};
use syntax::ext::hygiene::{Mark, SyntaxContext};
use syntax::ast::{self, FloatTy};
}
// Map from the name in a pattern to its binding mode.
-type BindingMap = FnvHashMap<Ident, BindingInfo>;
+type BindingMap = FxHashMap<Ident, BindingInfo>;
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum PatternSource {
/// One local scope.
#[derive(Debug)]
struct Rib<'a> {
- bindings: FnvHashMap<Ident, Def>,
+ bindings: FxHashMap<Ident, Def>,
kind: RibKind<'a>,
}
impl<'a> Rib<'a> {
fn new(kind: RibKind<'a>) -> Rib<'a> {
Rib {
- bindings: FnvHashMap(),
+ bindings: FxHashMap(),
kind: kind,
}
}
// is the NodeId of the local `extern crate` item (otherwise, `extern_crate_id` is None).
extern_crate_id: Option<NodeId>,
- resolutions: RefCell<FnvHashMap<(Name, Namespace), &'a RefCell<NameResolution<'a>>>>,
+ resolutions: RefCell<FxHashMap<(Name, Namespace), &'a RefCell<NameResolution<'a>>>>,
no_implicit_prelude: bool,
kind: kind,
normal_ancestor_id: None,
extern_crate_id: None,
- resolutions: RefCell::new(FnvHashMap()),
+ resolutions: RefCell::new(FxHashMap()),
no_implicit_prelude: false,
glob_importers: RefCell::new(Vec::new()),
globs: RefCell::new((Vec::new())),
/// Interns the names of the primitive types.
struct PrimitiveTypeTable {
- primitive_types: FnvHashMap<Name, PrimTy>,
+ primitive_types: FxHashMap<Name, PrimTy>,
}
impl PrimitiveTypeTable {
fn new() -> PrimitiveTypeTable {
- let mut table = PrimitiveTypeTable { primitive_types: FnvHashMap() };
+ let mut table = PrimitiveTypeTable { primitive_types: FxHashMap() };
table.intern("bool", TyBool);
table.intern("char", TyChar);
// Maps the node id of a statement to the expansions of the `macro_rules!`s
// immediately above the statement (if appropriate).
- macros_at_scope: FnvHashMap<NodeId, Vec<Mark>>,
+ macros_at_scope: FxHashMap<NodeId, Vec<Mark>>,
graph_root: Module<'a>,
prelude: Option<Module<'a>>,
- trait_item_map: FnvHashMap<(Name, DefId), bool /* is static method? */>,
+ trait_item_map: FxHashMap<(Name, DefId), bool /* is static method? */>,
// Names of fields of an item `DefId` accessible with dot syntax.
// Used for hints during error reporting.
- field_names: FnvHashMap<DefId, Vec<Name>>,
+ field_names: FxHashMap<DefId, Vec<Name>>,
// All imports known to succeed or fail.
determined_imports: Vec<&'a ImportDirective<'a>>,
// all imports, but only glob imports are actually interesting).
pub glob_map: GlobMap,
- used_imports: FnvHashSet<(NodeId, Namespace)>,
- used_crates: FnvHashSet<CrateNum>,
+ used_imports: FxHashSet<(NodeId, Namespace)>,
+ used_crates: FxHashSet<CrateNum>,
pub maybe_unused_trait_imports: NodeSet,
privacy_errors: Vec<PrivacyError<'a>>,
pub exported_macros: Vec<ast::MacroDef>,
crate_loader: &'a mut CrateLoader,
- macro_names: FnvHashSet<Name>,
- builtin_macros: FnvHashMap<Name, Rc<SyntaxExtension>>,
+ macro_names: FxHashSet<Name>,
+ builtin_macros: FxHashMap<Name, Rc<SyntaxExtension>>,
lexical_macro_resolutions: Vec<(Name, LegacyScope<'a>)>,
// Maps the `Mark` of an expansion to its containing module or block.
- invocations: FnvHashMap<Mark, &'a InvocationData<'a>>,
+ invocations: FxHashMap<Mark, &'a InvocationData<'a>>,
}
pub struct ResolverArenas<'a> {
let mut definitions = Definitions::new();
DefCollector::new(&mut definitions).collect_root();
- let mut invocations = FnvHashMap();
+ let mut invocations = FxHashMap();
invocations.insert(Mark::root(),
arenas.alloc_invocation_data(InvocationData::root(graph_root)));
session: session,
definitions: definitions,
- macros_at_scope: FnvHashMap(),
+ macros_at_scope: FxHashMap(),
// The outermost module has def ID 0; this is not reflected in the
// AST.
graph_root: graph_root,
prelude: None,
- trait_item_map: FnvHashMap(),
- field_names: FnvHashMap(),
+ trait_item_map: FxHashMap(),
+ field_names: FxHashMap(),
determined_imports: Vec::new(),
indeterminate_imports: Vec::new(),
make_glob_map: make_glob_map == MakeGlobMap::Yes,
glob_map: NodeMap(),
- used_imports: FnvHashSet(),
- used_crates: FnvHashSet(),
+ used_imports: FxHashSet(),
+ used_crates: FxHashSet(),
maybe_unused_trait_imports: NodeSet(),
privacy_errors: Vec::new(),
exported_macros: Vec::new(),
crate_loader: crate_loader,
- macro_names: FnvHashSet(),
- builtin_macros: FnvHashMap(),
+ macro_names: FxHashSet(),
+ builtin_macros: FxHashMap(),
lexical_macro_resolutions: Vec::new(),
invocations: invocations,
}
fn add_to_glob_map(&mut self, id: NodeId, name: Name) {
if self.make_glob_map {
- self.glob_map.entry(id).or_insert_with(FnvHashSet).insert(name);
+ self.glob_map.entry(id).or_insert_with(FxHashSet).insert(name);
}
}
match type_parameters {
HasTypeParameters(generics, rib_kind) => {
let mut function_type_rib = Rib::new(rib_kind);
- let mut seen_bindings = FnvHashMap();
+ let mut seen_bindings = FxHashMap();
for type_parameter in &generics.ty_params {
let name = type_parameter.ident.name;
debug!("with_type_parameter_rib: {}", type_parameter.id);
self.label_ribs.push(Rib::new(rib_kind));
// Add each argument to the rib.
- let mut bindings_list = FnvHashMap();
+ let mut bindings_list = FxHashMap();
for argument in &declaration.inputs {
self.resolve_pattern(&argument.pat, PatternSource::FnParam, &mut bindings_list);
walk_list!(self, visit_expr, &local.init);
// Resolve the pattern.
- self.resolve_pattern(&local.pat, PatternSource::Let, &mut FnvHashMap());
+ self.resolve_pattern(&local.pat, PatternSource::Let, &mut FxHashMap());
}
// build a map from pattern identifiers to binding-info's.
// that expands into an or-pattern where one 'x' was from the
// user and one 'x' came from the macro.
fn binding_mode_map(&mut self, pat: &Pat) -> BindingMap {
- let mut binding_map = FnvHashMap();
+ let mut binding_map = FxHashMap();
pat.walk(&mut |pat| {
if let PatKind::Ident(binding_mode, ident, ref sub_pat) = pat.node {
fn resolve_arm(&mut self, arm: &Arm) {
self.value_ribs.push(Rib::new(NormalRibKind));
- let mut bindings_list = FnvHashMap();
+ let mut bindings_list = FxHashMap();
for pattern in &arm.pats {
self.resolve_pattern(&pattern, PatternSource::Match, &mut bindings_list);
}
pat_id: NodeId,
outer_pat_id: NodeId,
pat_src: PatternSource,
- bindings: &mut FnvHashMap<Ident, NodeId>)
+ bindings: &mut FxHashMap<Ident, NodeId>)
-> PathResolution {
// Add the binding to the local ribs, if it
// doesn't already exist in the bindings map. (We
pat_src: PatternSource,
// Maps idents to the node ID for the
// outermost pattern that binds them.
- bindings: &mut FnvHashMap<Ident, NodeId>) {
+ bindings: &mut FxHashMap<Ident, NodeId>) {
// Visit all direct subpatterns of this pattern.
let outer_pat_id = pat.id;
pat.walk(&mut |pat| {
self.visit_expr(subexpression);
self.value_ribs.push(Rib::new(NormalRibKind));
- self.resolve_pattern(pattern, PatternSource::IfLet, &mut FnvHashMap());
+ self.resolve_pattern(pattern, PatternSource::IfLet, &mut FxHashMap());
self.visit_block(if_block);
self.value_ribs.pop();
ExprKind::WhileLet(ref pattern, ref subexpression, ref block, label) => {
self.visit_expr(subexpression);
self.value_ribs.push(Rib::new(NormalRibKind));
- self.resolve_pattern(pattern, PatternSource::WhileLet, &mut FnvHashMap());
+ self.resolve_pattern(pattern, PatternSource::WhileLet, &mut FxHashMap());
self.resolve_labeled_block(label, expr.id, block);
ExprKind::ForLoop(ref pattern, ref subexpression, ref block, label) => {
self.visit_expr(subexpression);
self.value_ribs.push(Rib::new(NormalRibKind));
- self.resolve_pattern(pattern, PatternSource::For, &mut FnvHashMap());
+ self.resolve_pattern(pattern, PatternSource::For, &mut FxHashMap());
self.resolve_labeled_block(label, expr.id, block);
fn report_errors(&mut self) {
self.report_shadowing_errors();
- let mut reported_spans = FnvHashSet();
+ let mut reported_spans = FxHashSet();
for &AmbiguityError { span, name, b1, b2 } in &self.ambiguity_errors {
if !reported_spans.insert(span) { continue }
self.resolve_macro_name(scope, name);
}
- let mut reported_errors = FnvHashSet();
+ let mut reported_errors = FxHashSet();
for binding in replace(&mut self.disallowed_shadowing, Vec::new()) {
if self.resolve_macro_name(binding.parent, binding.name).is_some() &&
reported_errors.insert((binding.name, binding.span)) {
use type_of;
use value::Value;
use Disr;
-use util::nodemap::{NodeSet, FnvHashMap, FnvHashSet};
+use util::nodemap::{NodeSet, FxHashMap, FxHashSet};
use arena::TypedArena;
use libc::c_uint;
fn internalize_symbols<'a, 'tcx>(sess: &Session,
ccxs: &CrateContextList<'a, 'tcx>,
symbol_map: &SymbolMap<'tcx>,
- reachable: &FnvHashSet<&str>) {
+ reachable: &FxHashSet<&str>) {
let scx = ccxs.shared();
let tcx = scx.tcx();
// 'unsafe' because we are holding on to CStr's from the LLVM module within
// this block.
unsafe {
- let mut referenced_somewhere = FnvHashSet();
+ let mut referenced_somewhere = FxHashSet();
// Collect all symbols that need to stay externally visible because they
// are referenced via a declaration in some other codegen unit.
// Also collect all symbols for which we cannot adjust linkage, because
// it is fixed by some directive in the source code (e.g. #[no_mangle]).
- let linkage_fixed_explicitly: FnvHashSet<_> = scx
+ let linkage_fixed_explicitly: FxHashSet<_> = scx
.translation_items()
.borrow()
.iter()
}
if scx.sess().opts.debugging_opts.print_trans_items.is_some() {
- let mut item_to_cgus = FnvHashMap();
+ let mut item_to_cgus = FxHashMap();
for cgu in &codegen_units {
for (&trans_item, &linkage) in cgu.items() {
use machine::llalign_of_pref;
use type_::Type;
use value::Value;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use libc::{c_uint, c_char};
use std::borrow::Cow;
// Build version of path with cycles removed.
// Pass 1: scan table mapping str -> rightmost pos.
- let mut mm = FnvHashMap();
+ let mut mm = FxHashMap();
let len = v.len();
let mut i = 0;
while i < len {
use common::{fulfill_obligation, type_is_sized};
use glue::{self, DropGlueKind};
use monomorphize::{self, Instance};
-use util::nodemap::{FnvHashSet, FnvHashMap, DefIdMap};
+use util::nodemap::{FxHashSet, FxHashMap, DefIdMap};
use trans_item::{TransItem, type_to_string, def_id_to_string};
// that are potentially inlined by LLVM into the source.
// The two numbers in the tuple are the start (inclusive) and
// end index (exclusive) within the `targets` vecs.
- index: FnvHashMap<TransItem<'tcx>, (usize, usize)>,
+ index: FxHashMap<TransItem<'tcx>, (usize, usize)>,
targets: Vec<TransItem<'tcx>>,
}
fn new() -> InliningMap<'tcx> {
InliningMap {
- index: FnvHashMap(),
+ index: FxHashMap(),
targets: Vec::new(),
}
}
pub fn collect_crate_translation_items<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
mode: TransItemCollectionMode)
- -> (FnvHashSet<TransItem<'tcx>>,
+ -> (FxHashSet<TransItem<'tcx>>,
InliningMap<'tcx>) {
// We are not tracking dependencies of this pass as it has to be re-executed
// every time no matter what.
let roots = collect_roots(scx, mode);
debug!("Building translation item graph, beginning at roots");
- let mut visited = FnvHashSet();
+ let mut visited = FxHashSet();
let mut recursion_depths = DefIdMap();
let mut inlining_map = InliningMap::new();
// Collect all monomorphized translation items reachable from `starting_point`
fn collect_items_rec<'a, 'tcx: 'a>(scx: &SharedCrateContext<'a, 'tcx>,
starting_point: TransItem<'tcx>,
- visited: &mut FnvHashSet<TransItem<'tcx>>,
+ visited: &mut FxHashSet<TransItem<'tcx>>,
recursion_depths: &mut DefIdMap<usize>,
inlining_map: &mut InliningMap<'tcx>) {
if !visited.insert(starting_point.clone()) {
if let Some(trait_ref) = tcx.impl_trait_ref(impl_def_id) {
let callee_substs = tcx.erase_regions(&trait_ref.substs);
- let overridden_methods: FnvHashSet<_> = items.iter()
- .map(|item| item.name)
- .collect();
+ let overridden_methods: FxHashSet<_> = items.iter()
+ .map(|item| item.name)
+ .collect();
for method in tcx.provided_trait_methods(trait_ref.def_id) {
if overridden_methods.contains(&method.name) {
continue;
use session::Session;
use session::config;
use symbol_map::SymbolMap;
-use util::nodemap::{NodeSet, DefIdMap, FnvHashMap, FnvHashSet};
+use util::nodemap::{NodeSet, DefIdMap, FxHashMap, FxHashSet};
use std::ffi::{CStr, CString};
use std::cell::{Cell, RefCell};
pub n_inlines: Cell<usize>,
pub n_closures: Cell<usize>,
pub n_llvm_insns: Cell<usize>,
- pub llvm_insns: RefCell<FnvHashMap<String, usize>>,
+ pub llvm_insns: RefCell<FxHashMap<String, usize>>,
// (ident, llvm-instructions)
pub fn_stats: RefCell<Vec<(String, usize)> >,
}
use_dll_storage_attrs: bool,
- translation_items: RefCell<FnvHashSet<TransItem<'tcx>>>,
+ translation_items: RefCell<FxHashSet<TransItem<'tcx>>>,
trait_cache: RefCell<DepTrackingMap<TraitSelectionCache<'tcx>>>,
project_cache: RefCell<DepTrackingMap<ProjectionCache<'tcx>>>,
}
previous_work_product: Option<WorkProduct>,
tn: TypeNames, // FIXME: This seems to be largely unused.
codegen_unit: CodegenUnit<'tcx>,
- needs_unwind_cleanup_cache: RefCell<FnvHashMap<Ty<'tcx>, bool>>,
- fn_pointer_shims: RefCell<FnvHashMap<Ty<'tcx>, ValueRef>>,
- drop_glues: RefCell<FnvHashMap<DropGlueKind<'tcx>, (ValueRef, FnType)>>,
+ needs_unwind_cleanup_cache: RefCell<FxHashMap<Ty<'tcx>, bool>>,
+ fn_pointer_shims: RefCell<FxHashMap<Ty<'tcx>, ValueRef>>,
+ drop_glues: RefCell<FxHashMap<DropGlueKind<'tcx>, (ValueRef, FnType)>>,
/// Cache instances of monomorphic and polymorphic items
- instances: RefCell<FnvHashMap<Instance<'tcx>, ValueRef>>,
+ instances: RefCell<FxHashMap<Instance<'tcx>, ValueRef>>,
/// Cache generated vtables
- vtables: RefCell<FnvHashMap<ty::PolyTraitRef<'tcx>, ValueRef>>,
+ vtables: RefCell<FxHashMap<ty::PolyTraitRef<'tcx>, ValueRef>>,
/// Cache of constant strings,
- const_cstr_cache: RefCell<FnvHashMap<InternedString, ValueRef>>,
+ const_cstr_cache: RefCell<FxHashMap<InternedString, ValueRef>>,
/// Reverse-direction for const ptrs cast from globals.
/// Key is a ValueRef holding a *T,
/// when we ptrcast, and we have to ptrcast during translation
/// of a [T] const because we form a slice, a (*T,usize) pair, not
/// a pointer to an LLVM array type. Similar for trait objects.
- const_unsized: RefCell<FnvHashMap<ValueRef, ValueRef>>,
+ const_unsized: RefCell<FxHashMap<ValueRef, ValueRef>>,
/// Cache of emitted const globals (value -> global)
- const_globals: RefCell<FnvHashMap<ValueRef, ValueRef>>,
+ const_globals: RefCell<FxHashMap<ValueRef, ValueRef>>,
/// Cache of emitted const values
- const_values: RefCell<FnvHashMap<(ast::NodeId, &'tcx Substs<'tcx>), ValueRef>>,
+ const_values: RefCell<FxHashMap<(ast::NodeId, &'tcx Substs<'tcx>), ValueRef>>,
/// Cache of external const values
extern_const_values: RefCell<DefIdMap<ValueRef>>,
/// Mapping from static definitions to their DefId's.
- statics: RefCell<FnvHashMap<ValueRef, DefId>>,
+ statics: RefCell<FxHashMap<ValueRef, DefId>>,
- impl_method_cache: RefCell<FnvHashMap<(DefId, ast::Name), DefId>>,
+ impl_method_cache: RefCell<FxHashMap<(DefId, ast::Name), DefId>>,
/// Cache of closure wrappers for bare fn's.
- closure_bare_wrapper_cache: RefCell<FnvHashMap<ValueRef, ValueRef>>,
+ closure_bare_wrapper_cache: RefCell<FxHashMap<ValueRef, ValueRef>>,
/// List of globals for static variables which need to be passed to the
/// LLVM function ReplaceAllUsesWith (RAUW) when translation is complete.
/// to constants.)
statics_to_rauw: RefCell<Vec<(ValueRef, ValueRef)>>,
- lltypes: RefCell<FnvHashMap<Ty<'tcx>, Type>>,
- llsizingtypes: RefCell<FnvHashMap<Ty<'tcx>, Type>>,
- type_hashcodes: RefCell<FnvHashMap<Ty<'tcx>, String>>,
+ lltypes: RefCell<FxHashMap<Ty<'tcx>, Type>>,
+ llsizingtypes: RefCell<FxHashMap<Ty<'tcx>, Type>>,
+ type_hashcodes: RefCell<FxHashMap<Ty<'tcx>, String>>,
int_type: Type,
opaque_vec_type: Type,
builder: BuilderRef_res,
/// Holds the LLVM values for closure IDs.
- closure_vals: RefCell<FnvHashMap<Instance<'tcx>, ValueRef>>,
+ closure_vals: RefCell<FxHashMap<Instance<'tcx>, ValueRef>>,
dbg_cx: Option<debuginfo::CrateDebugContext<'tcx>>,
eh_unwind_resume: Cell<Option<ValueRef>>,
rust_try_fn: Cell<Option<ValueRef>>,
- intrinsics: RefCell<FnvHashMap<&'static str, ValueRef>>,
+ intrinsics: RefCell<FxHashMap<&'static str, ValueRef>>,
/// Number of LLVM instructions translated into this `LocalCrateContext`.
/// This is used to perform some basic load-balancing to keep all LLVM
n_inlines: Cell::new(0),
n_closures: Cell::new(0),
n_llvm_insns: Cell::new(0),
- llvm_insns: RefCell::new(FnvHashMap()),
+ llvm_insns: RefCell::new(FxHashMap()),
fn_stats: RefCell::new(Vec::new()),
},
check_overflow: check_overflow,
use_dll_storage_attrs: use_dll_storage_attrs,
- translation_items: RefCell::new(FnvHashSet()),
+ translation_items: RefCell::new(FxHashSet()),
trait_cache: RefCell::new(DepTrackingMap::new(tcx.dep_graph.clone())),
project_cache: RefCell::new(DepTrackingMap::new(tcx.dep_graph.clone())),
}
self.use_dll_storage_attrs
}
- pub fn translation_items(&self) -> &RefCell<FnvHashSet<TransItem<'tcx>>> {
+ pub fn translation_items(&self) -> &RefCell<FxHashSet<TransItem<'tcx>>> {
&self.translation_items
}
previous_work_product: previous_work_product,
codegen_unit: codegen_unit,
tn: TypeNames::new(),
- needs_unwind_cleanup_cache: RefCell::new(FnvHashMap()),
- fn_pointer_shims: RefCell::new(FnvHashMap()),
- drop_glues: RefCell::new(FnvHashMap()),
- instances: RefCell::new(FnvHashMap()),
- vtables: RefCell::new(FnvHashMap()),
- const_cstr_cache: RefCell::new(FnvHashMap()),
- const_unsized: RefCell::new(FnvHashMap()),
- const_globals: RefCell::new(FnvHashMap()),
- const_values: RefCell::new(FnvHashMap()),
+ needs_unwind_cleanup_cache: RefCell::new(FxHashMap()),
+ fn_pointer_shims: RefCell::new(FxHashMap()),
+ drop_glues: RefCell::new(FxHashMap()),
+ instances: RefCell::new(FxHashMap()),
+ vtables: RefCell::new(FxHashMap()),
+ const_cstr_cache: RefCell::new(FxHashMap()),
+ const_unsized: RefCell::new(FxHashMap()),
+ const_globals: RefCell::new(FxHashMap()),
+ const_values: RefCell::new(FxHashMap()),
extern_const_values: RefCell::new(DefIdMap()),
- statics: RefCell::new(FnvHashMap()),
- impl_method_cache: RefCell::new(FnvHashMap()),
- closure_bare_wrapper_cache: RefCell::new(FnvHashMap()),
+ statics: RefCell::new(FxHashMap()),
+ impl_method_cache: RefCell::new(FxHashMap()),
+ closure_bare_wrapper_cache: RefCell::new(FxHashMap()),
statics_to_rauw: RefCell::new(Vec::new()),
- lltypes: RefCell::new(FnvHashMap()),
- llsizingtypes: RefCell::new(FnvHashMap()),
- type_hashcodes: RefCell::new(FnvHashMap()),
+ lltypes: RefCell::new(FxHashMap()),
+ llsizingtypes: RefCell::new(FxHashMap()),
+ type_hashcodes: RefCell::new(FxHashMap()),
int_type: Type::from_ref(ptr::null_mut()),
opaque_vec_type: Type::from_ref(ptr::null_mut()),
builder: BuilderRef_res(llvm::LLVMCreateBuilderInContext(llcx)),
- closure_vals: RefCell::new(FnvHashMap()),
+ closure_vals: RefCell::new(FxHashMap()),
dbg_cx: dbg_cx,
eh_personality: Cell::new(None),
eh_unwind_resume: Cell::new(None),
rust_try_fn: Cell::new(None),
- intrinsics: RefCell::new(FnvHashMap()),
+ intrinsics: RefCell::new(FxHashMap()),
n_llvm_insns: Cell::new(0),
type_of_depth: Cell::new(0),
symbol_map: symbol_map,
&self.shared.link_meta
}
- pub fn needs_unwind_cleanup_cache(&self) -> &RefCell<FnvHashMap<Ty<'tcx>, bool>> {
+ pub fn needs_unwind_cleanup_cache(&self) -> &RefCell<FxHashMap<Ty<'tcx>, bool>> {
&self.local().needs_unwind_cleanup_cache
}
- pub fn fn_pointer_shims(&self) -> &RefCell<FnvHashMap<Ty<'tcx>, ValueRef>> {
+ pub fn fn_pointer_shims(&self) -> &RefCell<FxHashMap<Ty<'tcx>, ValueRef>> {
&self.local().fn_pointer_shims
}
pub fn drop_glues<'a>(&'a self)
- -> &'a RefCell<FnvHashMap<DropGlueKind<'tcx>, (ValueRef, FnType)>> {
+ -> &'a RefCell<FxHashMap<DropGlueKind<'tcx>, (ValueRef, FnType)>> {
&self.local().drop_glues
}
self.sess().cstore.defid_for_inlined_node(node_id)
}
- pub fn instances<'a>(&'a self) -> &'a RefCell<FnvHashMap<Instance<'tcx>, ValueRef>> {
+ pub fn instances<'a>(&'a self) -> &'a RefCell<FxHashMap<Instance<'tcx>, ValueRef>> {
&self.local().instances
}
- pub fn vtables<'a>(&'a self) -> &'a RefCell<FnvHashMap<ty::PolyTraitRef<'tcx>, ValueRef>> {
+ pub fn vtables<'a>(&'a self) -> &'a RefCell<FxHashMap<ty::PolyTraitRef<'tcx>, ValueRef>> {
&self.local().vtables
}
- pub fn const_cstr_cache<'a>(&'a self) -> &'a RefCell<FnvHashMap<InternedString, ValueRef>> {
+ pub fn const_cstr_cache<'a>(&'a self) -> &'a RefCell<FxHashMap<InternedString, ValueRef>> {
&self.local().const_cstr_cache
}
- pub fn const_unsized<'a>(&'a self) -> &'a RefCell<FnvHashMap<ValueRef, ValueRef>> {
+ pub fn const_unsized<'a>(&'a self) -> &'a RefCell<FxHashMap<ValueRef, ValueRef>> {
&self.local().const_unsized
}
- pub fn const_globals<'a>(&'a self) -> &'a RefCell<FnvHashMap<ValueRef, ValueRef>> {
+ pub fn const_globals<'a>(&'a self) -> &'a RefCell<FxHashMap<ValueRef, ValueRef>> {
&self.local().const_globals
}
- pub fn const_values<'a>(&'a self) -> &'a RefCell<FnvHashMap<(ast::NodeId, &'tcx Substs<'tcx>),
- ValueRef>> {
+ pub fn const_values<'a>(&'a self) -> &'a RefCell<FxHashMap<(ast::NodeId, &'tcx Substs<'tcx>),
+ ValueRef>> {
&self.local().const_values
}
&self.local().extern_const_values
}
- pub fn statics<'a>(&'a self) -> &'a RefCell<FnvHashMap<ValueRef, DefId>> {
+ pub fn statics<'a>(&'a self) -> &'a RefCell<FxHashMap<ValueRef, DefId>> {
&self.local().statics
}
pub fn impl_method_cache<'a>(&'a self)
- -> &'a RefCell<FnvHashMap<(DefId, ast::Name), DefId>> {
+ -> &'a RefCell<FxHashMap<(DefId, ast::Name), DefId>> {
&self.local().impl_method_cache
}
- pub fn closure_bare_wrapper_cache<'a>(&'a self) -> &'a RefCell<FnvHashMap<ValueRef, ValueRef>> {
+ pub fn closure_bare_wrapper_cache<'a>(&'a self) -> &'a RefCell<FxHashMap<ValueRef, ValueRef>> {
&self.local().closure_bare_wrapper_cache
}
&self.local().statics_to_rauw
}
- pub fn lltypes<'a>(&'a self) -> &'a RefCell<FnvHashMap<Ty<'tcx>, Type>> {
+ pub fn lltypes<'a>(&'a self) -> &'a RefCell<FxHashMap<Ty<'tcx>, Type>> {
&self.local().lltypes
}
- pub fn llsizingtypes<'a>(&'a self) -> &'a RefCell<FnvHashMap<Ty<'tcx>, Type>> {
+ pub fn llsizingtypes<'a>(&'a self) -> &'a RefCell<FxHashMap<Ty<'tcx>, Type>> {
&self.local().llsizingtypes
}
- pub fn type_hashcodes<'a>(&'a self) -> &'a RefCell<FnvHashMap<Ty<'tcx>, String>> {
+ pub fn type_hashcodes<'a>(&'a self) -> &'a RefCell<FxHashMap<Ty<'tcx>, String>> {
&self.local().type_hashcodes
}
self.local().opaque_vec_type
}
- pub fn closure_vals<'a>(&'a self) -> &'a RefCell<FnvHashMap<Instance<'tcx>, ValueRef>> {
+ pub fn closure_vals<'a>(&'a self) -> &'a RefCell<FxHashMap<Instance<'tcx>, ValueRef>> {
&self.local().closure_vals
}
&self.local().rust_try_fn
}
- fn intrinsics<'a>(&'a self) -> &'a RefCell<FnvHashMap<&'static str, ValueRef>> {
+ fn intrinsics<'a>(&'a self) -> &'a RefCell<FxHashMap<&'static str, ValueRef>> {
&self.local().intrinsics
}
&*self.local().symbol_map
}
- pub fn translation_items(&self) -> &RefCell<FnvHashSet<TransItem<'tcx>>> {
+ pub fn translation_items(&self) -> &RefCell<FxHashSet<TransItem<'tcx>>> {
&self.shared.translation_items
}
use type_::Type;
use rustc::ty::{self, AdtKind, Ty, layout};
use session::config;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use util::common::path2cstr;
use libc::{c_uint, c_longlong};
// The UniqueTypeIds created so far
unique_id_interner: Interner,
// A map from UniqueTypeId to debuginfo metadata for that type. This is a 1:1 mapping.
- unique_id_to_metadata: FnvHashMap<UniqueTypeId, DIType>,
+ unique_id_to_metadata: FxHashMap<UniqueTypeId, DIType>,
// A map from types to debuginfo metadata. This is a N:1 mapping.
- type_to_metadata: FnvHashMap<Ty<'tcx>, DIType>,
+ type_to_metadata: FxHashMap<Ty<'tcx>, DIType>,
// A map from types to UniqueTypeId. This is a N:1 mapping.
- type_to_unique_id: FnvHashMap<Ty<'tcx>, UniqueTypeId>
+ type_to_unique_id: FxHashMap<Ty<'tcx>, UniqueTypeId>
}
impl<'tcx> TypeMap<'tcx> {
pub fn new() -> TypeMap<'tcx> {
TypeMap {
unique_id_interner: Interner::new(),
- type_to_metadata: FnvHashMap(),
- unique_id_to_metadata: FnvHashMap(),
- type_to_unique_id: FnvHashMap(),
+ type_to_metadata: FxHashMap(),
+ unique_id_to_metadata: FxHashMap(),
+ type_to_unique_id: FxHashMap(),
}
}
use rustc::ty::{self, Ty};
use rustc::mir;
use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo};
-use util::nodemap::{DefIdMap, FnvHashMap, FnvHashSet};
+use util::nodemap::{DefIdMap, FxHashMap, FxHashSet};
use libc::c_uint;
use std::cell::{Cell, RefCell};
llcontext: ContextRef,
builder: DIBuilderRef,
current_debug_location: Cell<InternalDebugLocation>,
- created_files: RefCell<FnvHashMap<String, DIFile>>,
- created_enum_disr_types: RefCell<FnvHashMap<(DefId, layout::Integer), DIType>>,
+ created_files: RefCell<FxHashMap<String, DIFile>>,
+ created_enum_disr_types: RefCell<FxHashMap<(DefId, layout::Integer), DIType>>,
type_map: RefCell<TypeMap<'tcx>>,
namespace_map: RefCell<DefIdMap<DIScope>>,
// This collection is used to assert that composite types (structs, enums,
// ...) have their members only set once:
- composite_types_completed: RefCell<FnvHashSet<DIType>>,
+ composite_types_completed: RefCell<FxHashSet<DIType>>,
}
impl<'tcx> CrateDebugContext<'tcx> {
llcontext: llcontext,
builder: builder,
current_debug_location: Cell::new(InternalDebugLocation::UnknownLocation),
- created_files: RefCell::new(FnvHashMap()),
- created_enum_disr_types: RefCell::new(FnvHashMap()),
+ created_files: RefCell::new(FxHashMap()),
+ created_enum_disr_types: RefCell::new(FxHashMap()),
type_map: RefCell::new(TypeMap::new()),
namespace_map: RefCell::new(DefIdMap()),
- composite_types_completed: RefCell::new(FnvHashSet()),
+ composite_types_completed: RefCell::new(FxHashSet()),
};
}
}
use glue;
use type_::Type;
-use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::fx::FxHashMap;
use syntax::parse::token;
use super::{MirContext, LocalRef};
adt::trans_get_discr(bcx, ty, discr_lvalue.llval, None, true)
);
- let mut bb_hist = FnvHashMap();
+ let mut bb_hist = FxHashMap();
for target in targets {
*bb_hist.entry(target).or_insert(0) += 1;
}
use syntax::ast::NodeId;
use syntax::parse::token::{self, InternedString};
use trans_item::TransItem;
-use util::nodemap::{FnvHashMap, FnvHashSet};
+use util::nodemap::{FxHashMap, FxHashSet};
pub enum PartitioningStrategy {
/// Generate one codegen unit per source-level module.
/// as well as the crate name and disambiguator.
name: InternedString,
- items: FnvHashMap<TransItem<'tcx>, llvm::Linkage>,
+ items: FxHashMap<TransItem<'tcx>, llvm::Linkage>,
}
impl<'tcx> CodegenUnit<'tcx> {
pub fn new(name: InternedString,
- items: FnvHashMap<TransItem<'tcx>, llvm::Linkage>)
+ items: FxHashMap<TransItem<'tcx>, llvm::Linkage>)
-> Self {
CodegenUnit {
name: name,
}
pub fn empty(name: InternedString) -> Self {
- Self::new(name, FnvHashMap())
+ Self::new(name, FxHashMap())
}
pub fn contains_item(&self, item: &TransItem<'tcx>) -> bool {
&self.name
}
- pub fn items(&self) -> &FnvHashMap<TransItem<'tcx>, llvm::Linkage> {
+ pub fn items(&self) -> &FxHashMap<TransItem<'tcx>, llvm::Linkage> {
&self.items
}
struct PreInliningPartitioning<'tcx> {
codegen_units: Vec<CodegenUnit<'tcx>>,
- roots: FnvHashSet<TransItem<'tcx>>,
+ roots: FxHashSet<TransItem<'tcx>>,
}
struct PostInliningPartitioning<'tcx>(Vec<CodegenUnit<'tcx>>);
where I: Iterator<Item = TransItem<'tcx>>
{
let tcx = scx.tcx();
- let mut roots = FnvHashSet();
- let mut codegen_units = FnvHashMap();
+ let mut roots = FxHashSet();
+ let mut codegen_units = FxHashMap();
for trans_item in trans_items {
let is_root = !trans_item.is_instantiated_only_on_demand(tcx);
for codegen_unit in &initial_partitioning.codegen_units[..] {
// Collect all items that need to be available in this codegen unit
- let mut reachable = FnvHashSet();
+ let mut reachable = FxHashSet();
for root in codegen_unit.items.keys() {
follow_inlining(*root, inlining_map, &mut reachable);
}
fn follow_inlining<'tcx>(trans_item: TransItem<'tcx>,
inlining_map: &InliningMap<'tcx>,
- visited: &mut FnvHashSet<TransItem<'tcx>>) {
+ visited: &mut FxHashSet<TransItem<'tcx>>) {
if !visited.insert(trans_item) {
return;
}
use std::borrow::Cow;
use syntax::codemap::Span;
use trans_item::TransItem;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
// In the SymbolMap we collect the symbol names of all translation items of
// the current crate. This map exists as a performance optimization. Symbol
// Thus they could also always be recomputed if needed.
pub struct SymbolMap<'tcx> {
- index: FnvHashMap<TransItem<'tcx>, (usize, usize)>,
+ index: FxHashMap<TransItem<'tcx>, (usize, usize)>,
arena: String,
}
}
let mut symbol_map = SymbolMap {
- index: FnvHashMap(),
+ index: FxHashMap(),
arena: String::with_capacity(1024),
};
use llvm::{Float, Double, X86_FP80, PPC_FP128, FP128};
use context::CrateContext;
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use syntax::ast;
use rustc::ty::layout;
/* Memory-managed object interface to type handles. */
pub struct TypeNames {
- named_types: RefCell<FnvHashMap<String, TypeRef>>,
+ named_types: RefCell<FxHashMap<String, TypeRef>>,
}
impl TypeNames {
pub fn new() -> TypeNames {
TypeNames {
- named_types: RefCell::new(FnvHashMap())
+ named_types: RefCell::new(FxHashMap())
}
}
ElisionFailureInfo, ElidedLifetime};
use rscope::{AnonTypeScope, MaybeWithAnonTypes};
use util::common::{ErrorReported, FN_OUTPUT_NAME};
-use util::nodemap::{NodeMap, FnvHashSet};
+use util::nodemap::{NodeMap, FxHashSet};
use std::cell::RefCell;
use syntax::{abi, ast};
let mut possible_implied_output_region = None;
for input_type in input_tys.iter() {
- let mut regions = FnvHashSet();
+ let mut regions = FxHashSet();
let have_bound_regions = tcx.collect_regions(input_type, &mut regions);
debug!("find_implied_output_regions: collected {:?} from {:?} \
return tcx.types.err;
}
- let mut associated_types = FnvHashSet::default();
+ let mut associated_types = FxHashSet::default();
for tr in traits::supertraits(tcx, principal) {
if let Some(trait_id) = tcx.map.as_local_node_id(tr.def_id()) {
use collect::trait_associated_type_names;
use rustc::infer::{self, InferOk, TypeOrigin};
use rustc::ty::{self, Ty, TypeFoldable, LvaluePreference};
use check::{FnCtxt, Expectation};
-use util::nodemap::FnvHashMap;
+use util::nodemap::FxHashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::cmp;
let field_map = variant.fields
.iter()
.map(|field| (field.name, field))
- .collect::<FnvHashMap<_, _>>();
+ .collect::<FxHashMap<_, _>>();
// Keep track of which fields have already appeared in the pattern.
- let mut used_fields = FnvHashMap();
+ let mut used_fields = FxHashMap();
// Typecheck each field.
for &Spanned { node: ref field, span } in fields {
use rustc::ty::subst::{Subst, Substs};
use rustc::ty::{self, AdtKind, Ty, TyCtxt};
use rustc::traits::{self, Reveal};
-use util::nodemap::FnvHashSet;
+use util::nodemap::FxHashSet;
use syntax::ast;
use syntax_pos::{self, Span};
rcx: rcx,
span: span,
parent_scope: parent_scope,
- breadcrumbs: FnvHashSet()
+ breadcrumbs: FxHashSet()
},
TypeContext::Root,
typ,
struct DropckContext<'a, 'b: 'a, 'gcx: 'b+'tcx, 'tcx: 'b> {
rcx: &'a mut RegionCtxt<'b, 'gcx, 'tcx>,
/// types that have already been traversed
- breadcrumbs: FnvHashSet<Ty<'tcx>>,
+ breadcrumbs: FxHashSet<Ty<'tcx>>,
/// span for error reporting
span: Span,
/// the scope reachable dtorck types must outlive
use rustc::ty::subst::Substs;
use rustc::ty::FnSig;
use rustc::ty::{self, Ty};
-use rustc::util::nodemap::FnvHashMap;
+use rustc::util::nodemap::FxHashMap;
use {CrateCtxt, require_same_types};
use syntax::abi::Abi;
return
}
- let mut structural_to_nomimal = FnvHashMap();
+ let mut structural_to_nomimal = FxHashMap();
let sig = tcx.no_late_bound_regions(i_ty.ty.fn_sig()).unwrap();
if intr.inputs.len() != sig.inputs.len() {
ccx: &CrateCtxt<'a, 'tcx>,
position: &str,
span: Span,
- structural_to_nominal: &mut FnvHashMap<&'a intrinsics::Type, ty::Ty<'tcx>>,
+ structural_to_nominal: &mut FxHashMap<&'a intrinsics::Type, ty::Ty<'tcx>>,
expected: &'a intrinsics::Type, t: ty::Ty<'tcx>)
{
use intrinsics::Type::*;
use rustc::traits;
use rustc::ty::{self, Ty, ToPolyTraitRef, TraitRef, TypeFoldable};
use rustc::infer::{InferOk, TypeOrigin};
-use rustc::util::nodemap::FnvHashSet;
+use rustc::util::nodemap::FxHashSet;
use syntax::ast;
use syntax_pos::{Span, DUMMY_SP};
use rustc::hir;
opt_simplified_steps: Option<Vec<ty::fast_reject::SimplifiedType>>,
inherent_candidates: Vec<Candidate<'tcx>>,
extension_candidates: Vec<Candidate<'tcx>>,
- impl_dups: FnvHashSet<DefId>,
+ impl_dups: FxHashSet<DefId>,
import_id: Option<ast::NodeId>,
/// Collects near misses when the candidate functions are missing a `self` keyword and is only
item_name: item_name,
inherent_candidates: Vec::new(),
extension_candidates: Vec::new(),
- impl_dups: FnvHashSet(),
+ impl_dups: FxHashSet(),
import_id: None,
steps: Rc::new(steps),
opt_simplified_steps: opt_simplified_steps,
fn assemble_extension_candidates_for_traits_in_scope(&mut self,
expr_id: ast::NodeId)
-> Result<(), MethodError<'tcx>> {
- let mut duplicates = FnvHashSet();
+ let mut duplicates = FxHashSet();
let opt_applicable_traits = self.tcx.trait_map.get(&expr_id);
if let Some(applicable_traits) = opt_applicable_traits {
for trait_candidate in applicable_traits {
}
fn assemble_extension_candidates_for_all_traits(&mut self) -> Result<(), MethodError<'tcx>> {
- let mut duplicates = FnvHashSet();
+ let mut duplicates = FxHashSet();
for trait_info in suggest::all_traits(self.ccx) {
if duplicates.insert(trait_info.def_id) {
self.assemble_extension_candidates_for_trait(trait_info.def_id)?;
use hir::def_id::{CRATE_DEF_INDEX, DefId};
use middle::lang_items::FnOnceTraitLangItem;
use rustc::traits::{Obligation, SelectionContext};
-use util::nodemap::FnvHashSet;
+use util::nodemap::FxHashSet;
use syntax::ast;
use errors::DiagnosticBuilder;
});
// Cross-crate:
- let mut external_mods = FnvHashSet();
+ let mut external_mods = FxHashSet();
fn handle_external_def(ccx: &CrateCtxt,
traits: &mut AllTraitsVec,
- external_mods: &mut FnvHashSet<DefId>,
+ external_mods: &mut FxHashSet<DefId>,
def: Def) {
let def_id = def.def_id();
match def {
use TypeAndSubsts;
use lint;
use util::common::{block_query, ErrorReported, indenter, loop_query};
-use util::nodemap::{DefIdMap, FnvHashMap, FnvHashSet, NodeMap};
+use util::nodemap::{DefIdMap, FxHashMap, FxHashSet, NodeMap};
use std::cell::{Cell, Ref, RefCell};
use std::mem::replace;
// We must collect the defaults *before* we do any unification. Because we have
// directly attached defaults to the type variables any unification that occurs
// will erase defaults causing conflicting defaults to be completely ignored.
- let default_map: FnvHashMap<_, _> =
+ let default_map: FxHashMap<_, _> =
unsolved_variables
.iter()
.filter_map(|t| self.default(t).map(|d| (t, d)))
.collect();
- let mut unbound_tyvars = FnvHashSet();
+ let mut unbound_tyvars = FxHashSet();
debug!("select_all_obligations_and_apply_defaults: defaults={:?}", default_map);
// table then apply defaults until we find a conflict. That default must be the one
// that caused conflict earlier.
fn find_conflicting_default(&self,
- unbound_vars: &FnvHashSet<Ty<'tcx>>,
- default_map: &FnvHashMap<&Ty<'tcx>, type_variable::Default<'tcx>>,
+ unbound_vars: &FxHashSet<Ty<'tcx>>,
+ default_map: &FxHashMap<&Ty<'tcx>, type_variable::Default<'tcx>>,
conflict: Ty<'tcx>)
-> Option<type_variable::Default<'tcx>> {
use rustc::ty::error::UnconstrainedNumeric::Neither;
_ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
};
- let mut remaining_fields = FnvHashMap();
+ let mut remaining_fields = FxHashMap();
for field in &variant.fields {
remaining_fields.insert(field.name, field);
}
- let mut seen_fields = FnvHashMap();
+ let mut seen_fields = FxHashMap();
let mut error_happened = false;
use rustc::infer::TypeOrigin;
use rustc::traits;
use rustc::ty::{self, Ty, TyCtxt};
-use rustc::util::nodemap::{FnvHashSet, FnvHashMap};
+use rustc::util::nodemap::{FxHashSet, FxHashMap};
use syntax::ast;
use syntax_pos::Span;
assert_eq!(ty_predicates.parent, None);
let variances = self.tcx().item_variances(item_def_id);
- let mut constrained_parameters: FnvHashSet<_> =
+ let mut constrained_parameters: FxHashSet<_> =
variances.iter().enumerate()
.filter(|&(_, &variance)| variance != ty::Bivariant)
.map(|(index, _)| Parameter(index as u32))
fn reject_shadowing_type_parameters(tcx: TyCtxt, span: Span, generics: &ty::Generics) {
let parent = tcx.lookup_generics(generics.parent.unwrap());
- let impl_params: FnvHashMap<_, _> = parent.types
- .iter()
- .map(|tp| (tp.name, tp.def_id))
- .collect();
+ let impl_params: FxHashMap<_, _> = parent.types
+ .iter()
+ .map(|tp| (tp.name, tp.def_id))
+ .collect();
for method_param in &generics.types {
if impl_params.contains_key(&method_param.name) {
use rscope::*;
use rustc::dep_graph::DepNode;
use util::common::{ErrorReported, MemoizationMap};
-use util::nodemap::{NodeMap, FnvHashMap, FnvHashSet};
+use util::nodemap::{NodeMap, FxHashMap, FxHashSet};
use {CrateCtxt, write_ty_to_tcx};
use rustc_const_math::ConstInt;
// Convert all the associated consts.
// Also, check if there are any duplicate associated items
- let mut seen_type_items = FnvHashMap();
- let mut seen_value_items = FnvHashMap();
+ let mut seen_type_items = FxHashMap();
+ let mut seen_value_items = FxHashMap();
for impl_item in impl_items {
let seen_items = match impl_item.node {
disr_val: ty::Disr,
def: &hir::VariantData)
-> ty::VariantDefData<'tcx, 'tcx> {
- let mut seen_fields: FnvHashMap<ast::Name, Span> = FnvHashMap();
+ let mut seen_fields: FxHashMap<ast::Name, Span> = FxHashMap();
let node_id = ccx.tcx.map.as_local_node_id(did).unwrap();
let fields = def.fields().iter().map(|f| {
let fid = ccx.tcx.map.local_def_id(f.id);
{
let inline_bounds = from_bounds(ccx, param_bounds);
let where_bounds = from_predicates(ccx, param_id, &where_clause.predicates);
- let all_bounds: FnvHashSet<_> = inline_bounds.into_iter()
- .chain(where_bounds)
- .collect();
+ let all_bounds: FxHashSet<_> = inline_bounds.into_iter()
+ .chain(where_bounds)
+ .collect();
return if all_bounds.len() > 1 {
ty::ObjectLifetimeDefault::Ambiguous
} else if all_bounds.len() == 0 {
// The trait reference is an input, so find all type parameters
// reachable from there, to start (if this is an inherent impl,
// then just examine the self type).
- let mut input_parameters: FnvHashSet<_> =
+ let mut input_parameters: FxHashSet<_> =
ctp::parameters_for(&impl_scheme.ty, false).into_iter().collect();
if let Some(ref trait_ref) = impl_trait_ref {
input_parameters.extend(ctp::parameters_for(trait_ref, false));
let impl_predicates = ccx.tcx.lookup_predicates(impl_def_id);
let impl_trait_ref = ccx.tcx.impl_trait_ref(impl_def_id);
- let mut input_parameters: FnvHashSet<_> =
+ let mut input_parameters: FxHashSet<_> =
ctp::parameters_for(&impl_scheme.ty, false).into_iter().collect();
if let Some(ref trait_ref) = impl_trait_ref {
input_parameters.extend(ctp::parameters_for(trait_ref, false));
ctp::identify_constrained_type_params(
&impl_predicates.predicates.as_slice(), impl_trait_ref, &mut input_parameters);
- let lifetimes_in_associated_types: FnvHashSet<_> = impl_items.iter()
+ let lifetimes_in_associated_types: FxHashSet<_> = impl_items.iter()
.map(|item| ccx.tcx.impl_or_trait_item(ccx.tcx.map.local_def_id(item.id)))
.filter_map(|item| match item {
ty::TypeTraitItem(ref assoc_ty) => assoc_ty.ty,
use rustc::ty::{self, Ty};
use rustc::ty::fold::{TypeFoldable, TypeVisitor};
-use rustc::util::nodemap::FnvHashSet;
+use rustc::util::nodemap::FxHashSet;
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub struct Parameter(pub u32);
pub fn identify_constrained_type_params<'tcx>(predicates: &[ty::Predicate<'tcx>],
impl_trait_ref: Option<ty::TraitRef<'tcx>>,
- input_parameters: &mut F
nvHashSet<Parameter>)
+ input_parameters: &mut F
xHashSet<Parameter>)
{
let mut predicates = predicates.to_owned();
setup_constraining_predicates(&mut predicates, impl_trait_ref, input_parameters);
/// think of any.
pub fn setup_constraining_predicates<'tcx>(predicates: &mut [ty::Predicate<'tcx>],
impl_trait_ref: Option<ty::TraitRef<'tcx>>,
- input_parameters: &mut F
nvHashSet<Parameter>)
+ input_parameters: &mut F
xHashSet<Parameter>)
{
// The canonical way of doing the needed topological sort
// would be a DFS, but getting the graph and its ownership
use rustc::hir::def_id::DefId;
use rustc::hir::print as pprust;
use rustc::ty::{self, TyCtxt};
-use rustc::util::nodemap::FnvHashSet;
+use rustc::util::nodemap::FxHashSet;
use rustc_const_eval::lookup_const_by_id;
.into_iter()
.map(|meth| meth.name.to_string())
.collect()
- }).unwrap_or(FnvHashSet());
+ }).unwrap_or(FxHashSet());
ret.push(clean::Item {
inner: clean::ImplItem(clean::Impl {
// If we're reexporting a reexport it may actually reexport something in
// two namespaces, so the target may be listed twice. Make sure we only
// visit each node at most once.
- let mut visited = FnvHashSet();
+ let mut visited = FxHashSet();
for item in tcx.sess.cstore.item_children(did) {
let def_id = item.def.def_id();
if tcx.sess.cstore.visibility(def_id) == ty::Visibility::Public {
use rustc::ty::subst::Substs;
use rustc::ty::{self, AdtKind};
use rustc::middle::stability;
-use rustc::util::nodemap::{FnvHashMap, FnvHashSet};
+use rustc::util::nodemap::{FxHashMap, FxHashSet};
use rustc::hir;
pub access_levels: Arc<AccessLevels<DefId>>,
// These are later on moved into `CACHEKEY`, leaving the map empty.
// Only here so that they can be filtered through the rustdoc passes.
- pub external_traits: FnvHashMap<DefId, Trait>,
+ pub external_traits: FxHashMap<DefId, Trait>,
}
struct CrateNum(def_id::CrateNum);
// Note that associated types also have a sized bound by default, but we
// don't actually know the set of associated types right here so that's
// handled in cleaning associated types
- let mut sized_params = FnvHashSet();
+ let mut sized_params = FxHashSet();
where_predicates.retain(|pred| {
match *pred {
WP::BoundPredicate { ty: Generic(ref g), ref bounds } => {
});
if let Some((tcx, &hir::ItemTy(ref ty, ref generics))) = tcx_and_alias {
let provided_params = &path.segments.last().unwrap().parameters;
- let mut ty_substs = FnvHashMap();
- let mut lt_substs = FnvHashMap();
+ let mut ty_substs = FxHashMap();
+ let mut lt_substs = FxHashMap();
for (i, ty_param) in generics.ty_params.iter().enumerate() {
let ty_param_def = tcx.expect_def(ty_param.id);
if let Some(ty) = provided_params.types().get(i).cloned()
pub struct Impl {
pub unsafety: hir::Unsafety,
pub generics: Generics,
- pub provided_trait_methods: FnvHashSet<String>,
+ pub provided_trait_methods: FxHashSet<String>,
pub trait_: Option<Type>,
pub for_: Type,
pub items: Vec<Item>,
.map(|meth| meth.name.to_string())
.collect()
})
- }).unwrap_or(FnvHashSet());
+ }).unwrap_or(FxHashSet());
ret.push(Item {
name: None,
use rustc::ty::{self, TyCtxt};
use rustc::hir::map as hir_map;
use rustc::lint;
-use rustc::util::nodemap::FnvHashMap;
+use rustc::util::nodemap::FxHashMap;
use rustc_trans::back::link;
use rustc_resolve as resolve;
use rustc_metadata::cstore::CStore;
NotTyped(&'a session::Session)
}
-pub type ExternalPaths = FnvHashMap<DefId, (Vec<String>, clean::TypeKind)>;
+pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>;
pub struct DocContext<'a, 'tcx: 'a> {
pub map: &'a hir_map::Map<'tcx>,
/// Later on moved into `html::render::CACHE_KEY`
pub renderinfo: RefCell<RenderInfo>,
/// Later on moved through `clean::Crate` into `html::render::CACHE_KEY`
- pub external_traits: RefCell<FnvHashMap<DefId, clean::Trait>>,
+ pub external_traits: RefCell<FxHashMap<DefId, clean::Trait>>,
// The current set of type and lifetime substitutions,
// for expanding type aliases at the HIR level:
/// Table type parameter definition -> substituted type
- pub ty_substs: RefCell<FnvHashMap<Def, clean::Type>>,
+ pub ty_substs: RefCell<FxHashMap<Def, clean::Type>>,
/// Table node id of lifetime parameter definition -> substituted lifetime
- pub lt_substs: RefCell<F
nvHashMap<ast::NodeId, clean::Lifetime>>,
+ pub lt_substs: RefCell<F
xHashMap<ast::NodeId, clean::Lifetime>>,
}
impl<'b, 'tcx> DocContext<'b, 'tcx> {
/// Call the closure with the given parameters set as
/// the substitutions for a type alias' RHS.
pub fn enter_alias<F, R>(&self,
- ty_substs: FnvHashMap<Def, clean::Type>,
- lt_substs: F
nvHashMap<ast::NodeId, clean::Lifetime>,
+ ty_substs: FxHashMap<Def, clean::Type>,
+ lt_substs: F
xHashMap<ast::NodeId, clean::Lifetime>,
f: F) -> R
where F: FnOnce() -> R {
let (old_tys, old_lts) =
use rustc::middle::privacy::AccessLevels;
use rustc::middle::stability;
use rustc::hir;
-use rustc::util::nodemap::{FnvHashMap, FnvHashSet};
+use rustc::util::nodemap::{FxHashMap, FxHashSet};
use rustc_data_structures::flock;
use clean::{self, Attributes, GetDefId, SelfTy, Mutability};
/// `true`.
pub include_sources: bool,
/// The local file sources we've emitted and their respective url-paths.
- pub local_sources: F
nvHashMap<PathBuf, String>,
+ pub local_sources: F
xHashMap<PathBuf, String>,
/// All the passes that were run on this crate.
- pub passes: FnvHashSet<String>,
+ pub passes: FxHashSet<String>,
/// The base-URL of the issue tracker for when an item has been tagged with
/// an issue number.
pub issue_tracker_base_url: Option<String>,
/// Mapping of typaram ids to the name of the type parameter. This is used
/// when pretty-printing a type (so pretty printing doesn't have to
/// painfully maintain a context like this)
- pub typarams: FnvHashMap<DefId, String>,
+ pub typarams: FxHashMap<DefId, String>,
/// Maps a type id to all known implementations for that type. This is only
/// recognized for intra-crate `ResolvedPath` types, and is used to print
///
/// The values of the map are a list of implementations and documentation
/// found on that implementation.
- pub impls: FnvHashMap<DefId, Vec<Impl>>,
+ pub impls: FxHashMap<DefId, Vec<Impl>>,
/// Maintains a mapping of local crate node ids to the fully qualified name
/// and "short type description" of that node. This is used when generating
/// URLs when a type is being linked to. External paths are not located in
/// this map because the `External` type itself has all the information
/// necessary.
- pub paths: FnvHashMap<DefId, (Vec<String>, ItemType)>,
+ pub paths: FxHashMap<DefId, (Vec<String>, ItemType)>,
/// Similar to `paths`, but only holds external paths. This is only used for
/// generating explicit hyperlinks to other crates.
- pub external_paths: FnvHashMap<DefId, (Vec<String>, ItemType)>,
+ pub external_paths: FxHashMap<DefId, (Vec<String>, ItemType)>,
/// This map contains information about all known traits of this crate.
/// Implementations of a crate should inherit the documentation of the
/// parent trait if no extra documentation is specified, and default methods
/// should show up in documentation about trait implementations.
- pub traits: FnvHashMap<DefId, clean::Trait>,
+ pub traits: FxHashMap<DefId, clean::Trait>,
/// When rendering traits, it's often useful to be able to list all
/// implementors of the trait, and this mapping is exactly, that: a mapping
/// of trait ids to the list of known implementors of the trait
- pub implementors: FnvHashMap<DefId, Vec<Implementor>>,
+ pub implementors: FxHashMap<DefId, Vec<Implementor>>,
/// Cache of where external crate documentation can be found.
- pub extern_locations: FnvHashMap<CrateNum, (String, ExternalLocation)>,
+ pub extern_locations: FxHashMap<CrateNum, (String, ExternalLocation)>,
/// Cache of where documentation for primitives can be found.
- pub primitive_locations: FnvHashMap<clean::PrimitiveType, CrateNum>,
+ pub primitive_locations: FxHashMap<clean::PrimitiveType, CrateNum>,
// Note that external items for which `doc(hidden)` applies to are shown as
// non-reachable while local items aren't. This is because we're reusing
parent_stack: Vec<DefId>,
parent_is_trait_impl: bool,
search_index: Vec<IndexItem>,
- seen_modules: FnvHashSet<DefId>,
+ seen_modules: FxHashSet<DefId>,
seen_mod: bool,
stripped_mod: bool,
deref_trait_did: Option<DefId>,
/// Later on moved into `CACHE_KEY`.
#[derive(Default)]
pub struct RenderInfo {
- pub inlined: FnvHashSet<DefId>,
+ pub inlined: FxHashSet<DefId>,
pub external_paths: ::core::ExternalPaths,
- pub external_typarams: FnvHashMap<DefId, String>,
+ pub external_typarams: FxHashMap<DefId, String>,
pub deref_trait_did: Option<DefId>,
pub deref_mut_trait_did: Option<DefId>,
}
thread_local!(static CACHE_KEY: RefCell<Arc<Cache>> = Default::default());
thread_local!(pub static CURRENT_LOCATION_KEY: RefCell<Vec<String>> =
RefCell::new(Vec::new()));
-thread_local!(static USED_ID_MAP: RefCell<FnvHashMap<String, usize>> =
+thread_local!(static USED_ID_MAP: RefCell<FxHashMap<String, usize>> =
RefCell::new(init_ids()));
-fn init_ids() -> FnvHashMap<String, usize> {
+fn init_ids() -> FxHashMap<String, usize> {
[
"main",
"search",
*s.borrow_mut() = if embedded {
init_ids()
} else {
- FnvHashMap()
+ FxHashMap()
};
});
}
pub fn run(mut krate: clean::Crate,
external_html: &ExternalHtml,
dst: PathBuf,
- passes: FnvHashSet<String>,
+ passes: FxHashSet<String>,
css_file_extension: Option<PathBuf>,
renderinfo: RenderInfo) -> Result<(), Error> {
let src_root = match krate.src.parent() {
src_root: src_root,
passes: passes,
include_sources: true,
- local_sources: FnvHashMap(),
+ local_sources: FxHashMap(),
issue_tracker_base_url: None,
layout: layout::Layout {
logo: "".to_string(),
.collect();
let mut cache = Cache {
- impls: FnvHashMap(),
+ impls: FxHashMap(),
external_paths: external_paths,
- paths: FnvHashMap(),
- implementors: FnvHashMap(),
+ paths: FxHashMap(),
+ implementors: FxHashMap(),
stack: Vec::new(),
parent_stack: Vec::new(),
search_index: Vec::new(),
parent_is_trait_impl: false,
- extern_locations: FnvHashMap(),
- primitive_locations: FnvHashMap(),
- seen_modules: FnvHashSet(),
+ extern_locations: FxHashMap(),
+ primitive_locations: FxHashMap(),
+ seen_modules: FxHashSet(),
seen_mod: false,
stripped_mod: false,
access_levels: krate.access_levels.clone(),
orphan_impl_items: Vec::new(),
- traits: mem::replace(&mut krate.external_traits, FnvHashMap()),
+ traits: mem::replace(&mut krate.external_traits, FxHashMap()),
deref_trait_did: deref_trait_did,
deref_mut_trait_did: deref_mut_trait_did,
typarams: external_typarams,
/// Build the search index from the collected metadata
fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String {
- let mut nodeid_to_pathid = FnvHashMap();
+ let mut nodeid_to_pathid = FxHashMap();
let mut crate_items = Vec::with_capacity(cache.search_index.len());
let mut crate_paths = Vec::<Json>::new();
#[derive(Copy, Clone)]
enum AssocItemLink<'a> {
Anchor(Option<&'a str>),
- GotoSource(DefId, &'a FnvHashSet<String>),
+ GotoSource(DefId, &'a FxHashSet<String>),
}
impl<'a> AssocItemLink<'a> {
use rustc::hir::def::Def;
use rustc::hir::def_id::LOCAL_CRATE;
use rustc::middle::privacy::AccessLevel;
-use rustc::util::nodemap::FnvHashSet;
+use rustc::util::nodemap::FxHashSet;
use rustc::hir;
pub module: Module,
pub attrs: hir::HirVec<ast::Attribute>,
pub cx: &'a core::DocContext<'a, 'tcx>,
- view_item_stack: F
nvHashSet<ast::NodeId>,
+ view_item_stack: F
xHashSet<ast::NodeId>,
inlining_from_glob: bool,
}
impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
pub fn new(cx: &'a core::DocContext<'a, 'tcx>) -> RustdocVisitor<'a, 'tcx> {
// If the root is reexported, terminate all recursion.
- let mut stack = FnvHashSet();
+ let mut stack = FxHashSet();
stack.insert(ast::CRATE_NODE_ID);
RustdocVisitor {
module: Module::new(None),
projects / rust.git / commitdiff