use ty::{self, Ty, TyCtxt, TypeFoldable};
use ty::fold::TypeFolder;
-use std::collections::hash_map::{self, Entry};
+use util::nodemap::FnvHashMap;
+use std::collections::hash_map::Entry;
use super::InferCtxt;
use super::unify_key::ToType;
pub struct TypeFreshener<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
freshen_count: u32,
- freshen_map: hash_map::HashMap<ty::InferTy, Ty<'tcx>>,
+ freshen_map: FnvHashMap<ty::InferTy, Ty<'tcx>>,
}
impl<'a, 'gcx, 'tcx> TypeFreshener<'a, 'gcx, 'tcx> {
TypeFreshener {
infcx: infcx,
freshen_count: 0,
- freshen_map: hash_map::HashMap::new(),
+ freshen_map: FnvHashMap(),
}
}
use hir::def::Def;
use hir::def_id::{DefId};
use lint;
+use util::nodemap::FnvHashSet;
-use std::collections::HashSet;
use syntax::{ast, codemap};
use syntax::attr;
use syntax_pos;
struct MarkSymbolVisitor<'a, 'tcx: 'a> {
worklist: Vec<ast::NodeId>,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- live_symbols: Box<HashSet<ast::NodeId>>,
+ live_symbols: Box<
FnvHashSet<ast::NodeId>>,
struct_has_extern_repr: bool,
ignore_non_const_paths: bool,
inherited_pub_visibility: bool,
MarkSymbolVisitor {
worklist: worklist,
tcx: tcx,
- live_symbols: box HashSet::new(),
+ live_symbols: box FnvHashSet(),
struct_has_extern_repr: false,
ignore_non_const_paths: false,
inherited_pub_visibility: false,
}
fn mark_live_symbols(&mut self) {
- let mut scanned = HashSet::new();
+ let mut scanned = FnvHashSet();
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<HashSet<ast::NodeId>> {
+ -> Box<
FnvHashSet<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<HashSet<ast::NodeId>>,
+ live_symbols: Box<
FnvHashSet<ast::NodeId>>,
}
impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
use ty::{self, TyCtxt};
use middle::privacy;
use session::config;
-use util::nodemap::NodeSet;
+use util::nodemap::{NodeSet, FnvHashSet};
-use std::collections::HashSet;
use syntax::abi::Abi;
use syntax::ast;
use syntax::attr;
// Step 2: Mark all symbols that the symbols on the worklist touch.
fn propagate(&mut self) {
- let mut scanned = HashSet::new();
+ let mut scanned = FnvHashSet();
loop {
let search_item = match self.worklist.pop() {
Some(item) => item,
use rustc::session::filesearch::{FileSearch, FileMatches, FileDoesntMatch};
use rustc::session::search_paths::PathKind;
use rustc::util::common;
+use rustc::util::nodemap::FnvHashMap;
use rustc_llvm as llvm;
use rustc_llvm::{False, ObjectFile, mk_section_iter};
use rustc_back::target::Target;
use std::cmp;
-use std::collections::HashMap;
use std::fmt;
use std::fs;
use std::io;
let rlib_prefix = format!("lib{}", self.crate_name);
let staticlib_prefix = format!("{}{}", staticpair.0, self.crate_name);
- let mut candidates = HashMap::new();
+ let mut candidates = FnvHashMap();
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(|| (HashMap::new(), HashMap::new()));
+ .or_insert_with(|| (FnvHashMap(), FnvHashMap()));
let (ref mut rlibs, ref mut dylibs) = *slot;
fs::canonicalize(path).map(|p| {
if rlib {
// 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 = HashMap::new();
+ let mut libraries = FnvHashMap();
for (_hash, (rlibs, dylibs)) in candidates {
let mut slot = None;
let rlib = self.extract_one(rlibs, CrateFlavor::Rlib, &mut slot);
// read the metadata from it if `*slot` is `None`. If the metadata couldn't
// be read, it is assumed that the file isn't a valid rust library (no
// errors are emitted).
- fn extract_one(&mut self, m: HashMap<PathBuf, PathKind>, flavor: CrateFlavor,
+ fn extract_one(&mut self, m:
FnvHashMap<PathBuf, PathKind>, flavor: CrateFlavor,
slot: &mut Option<(Svh, MetadataBlob)>) -> Option<(PathBuf, PathKind)> {
let mut ret: Option<(PathBuf, PathKind)> = None;
let mut error = 0;
// rlibs/dylibs.
let sess = self.sess;
let dylibname = self.dylibname();
- let mut rlibs = HashMap::new();
- let mut dylibs = HashMap::new();
+ let mut rlibs = FnvHashMap();
+ let mut dylibs = FnvHashMap();
{
let locs = locs.map(|l| PathBuf::from(l)).filter(|loc| {
if !loc.exists() {
use cstore::CStore;
use rustc::session::Session;
+use rustc::util::nodemap::{FnvHashSet, FnvHashMap};
-use std::collections::{HashSet, HashMap};
use syntax::parse::token;
use syntax::ast;
use syntax::attr;
span_err!(a, b, E0467, "bad macro reexport");
}
-pub type MacroSelection = HashMap<token::InternedString, Span>;
+pub type MacroSelection = FnvHashMap<token::InternedString, Span>;
impl<'a> ext::base::MacroLoader for MacroLoader<'a> {
fn load_crate(&mut self, extern_crate: &ast::Item, allows_macros: bool) -> Vec<ast::MacroDef> {
// Parse the attributes relating to macros.
- let mut import = Some(HashMap::new()); // None => load all
- let mut reexport = HashMap::new();
+ let mut import = Some(FnvHashMap()); // None => load all
+ let mut reexport = FnvHashMap();
for attr in &extern_crate.attrs {
let mut used = true;
}
let mut macros = Vec::new();
- let mut seen = HashSet::new();
+ let mut seen = FnvHashSet();
for mut def in self.reader.read_exported_macros(vi) {
let name = def.ident.name.as_str();
use Resolver;
use rustc::session::Session;
+use rustc::util::nodemap::FnvHashMap;
use syntax::ast;
use syntax::ext::hygiene::Mark;
use syntax::fold::{self, Folder};
use syntax::util::move_map::MoveMap;
use syntax::util::small_vector::SmallVector;
-use std::collections::HashMap;
use std::mem;
impl<'a> Resolver<'a> {
struct NodeIdAssigner<'a> {
sess: &'a Session,
- macros_at_scope: &'a mut HashMap<ast::NodeId, Vec<Mark>>,
+ macros_at_scope: &'a mut
FnvHashMap<ast::NodeId, Vec<Mark>>,
}
impl<'a> Folder for NodeIdAssigner<'a> {
use syntax_pos::Span;
use errors::DiagnosticBuilder;
-use std::collections::{HashMap, HashSet};
use std::cell::{Cell, RefCell};
use std::fmt;
use std::mem::replace;
}
// Map from the name in a pattern to its binding mode.
-type BindingMap = HashMap<ast::Ident, BindingInfo>;
+type BindingMap =
FnvHashMap<ast::Ident, BindingInfo>;
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum PatternSource {
/// One local scope.
#[derive(Debug)]
struct Rib<'a> {
- bindings: HashMap<ast::Ident, Def>,
+ bindings:
FnvHashMap<ast::Ident, Def>,
kind: RibKind<'a>,
}
impl<'a> Rib<'a> {
fn new(kind: RibKind<'a>) -> Rib<'a> {
Rib {
- bindings: HashMap::new(),
+ bindings: FnvHashMap(),
kind: kind,
}
}
// is the NodeId of the local `extern crate` item (otherwise, `extern_crate_id` is None).
extern_crate_id: Option<NodeId>,
- resolutions: RefCell<HashMap<(Name, Namespace), &'a RefCell<NameResolution<'a>>>>,
+ resolutions: RefCell<FnvHashMap<(Name, Namespace), &'a RefCell<NameResolution<'a>>>>,
no_implicit_prelude: Cell<bool>,
parent_link: parent_link,
def: def,
extern_crate_id: None,
- resolutions: RefCell::new(HashMap::new()),
+ resolutions: RefCell::new(FnvHashMap()),
no_implicit_prelude: Cell::new(false),
glob_importers: RefCell::new(Vec::new()),
globs: RefCell::new((Vec::new())),
/// Interns the names of the primitive types.
struct PrimitiveTypeTable {
- primitive_types: HashMap<Name, PrimTy>,
+ primitive_types: FnvHashMap<Name, PrimTy>,
}
impl PrimitiveTypeTable {
fn new() -> PrimitiveTypeTable {
- let mut table = PrimitiveTypeTable { primitive_types: HashMap::new() };
+ let mut table = PrimitiveTypeTable { primitive_types: FnvHashMap() };
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: HashMap<NodeId, Vec<Mark>>,
+ macros_at_scope: FnvHashMap<NodeId, Vec<Mark>>,
graph_root: Module<'a>,
// all imports, but only glob imports are actually interesting).
pub glob_map: GlobMap,
- used_imports: HashSet<(NodeId, Namespace)>,
- used_crates: HashSet<CrateNum>,
+ used_imports: FnvHashSet<(NodeId, Namespace)>,
+ used_crates: FnvHashSet<CrateNum>,
pub maybe_unused_trait_imports: NodeSet,
privacy_errors: Vec<PrivacyError<'a>>,
session: session,
definitions: Definitions::new(),
- macros_at_scope: HashMap::new(),
+ macros_at_scope: FnvHashMap(),
// The outermost module has def ID 0; this is not reflected in the
// AST.
make_glob_map: make_glob_map == MakeGlobMap::Yes,
glob_map: NodeMap(),
- used_imports: HashSet::new(),
- used_crates: HashSet::new(),
+ used_imports: FnvHashSet(),
+ used_crates: FnvHashSet(),
maybe_unused_trait_imports: NodeSet(),
privacy_errors: Vec::new(),
match type_parameters {
HasTypeParameters(generics, rib_kind) => {
let mut function_type_rib = Rib::new(rib_kind);
- let mut seen_bindings = HashMap::new();
+ let mut seen_bindings = FnvHashMap();
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 = HashMap::new();
+ let mut bindings_list = FnvHashMap();
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 HashMap::new());
+ self.resolve_pattern(&local.pat, PatternSource::Let, &mut FnvHashMap());
}
// 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 = HashMap::new();
+ let mut binding_map = FnvHashMap();
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 = HashMap::new();
+ let mut bindings_list = FnvHashMap();
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 HashMap<ast::Ident, NodeId>)
+ bindings: &mut
FnvHashMap<ast::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 HashMap<ast::Ident, NodeId>) {
+ bindings: &mut
FnvHashMap<ast::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 HashMap::new());
+ self.resolve_pattern(pattern, PatternSource::IfLet, &mut FnvHashMap());
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 HashMap::new());
+ self.resolve_pattern(pattern, PatternSource::WhileLet, &mut FnvHashMap());
self.resolve_labeled_block(label.map(|l| l.node), 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 HashMap::new());
+ self.resolve_pattern(pattern, PatternSource::For, &mut FnvHashMap());
self.resolve_labeled_block(label.map(|l| l.node), expr.id, block);
fn report_privacy_errors(&self) {
if self.privacy_errors.len() == 0 { return }
- let mut reported_spans = HashSet::new();
+ let mut reported_spans = FnvHashSet();
for &PrivacyError(span, name, binding) in &self.privacy_errors {
if !reported_spans.insert(span) { continue }
if binding.is_extern_crate() {
use value::Value;
use Disr;
use util::sha2::Sha256;
-use util::nodemap::{NodeSet, FnvHashSet};
+use util::nodemap::{NodeSet, FnvHashMap, FnvHashSet};
use arena::TypedArena;
use libc::c_uint;
use std::ffi::{CStr, CString};
use std::borrow::Cow;
use std::cell::{Cell, RefCell};
-use std::collections::HashMap;
use std::ptr;
use std::rc::Rc;
use std::str;
}
if scx.sess().opts.debugging_opts.print_trans_items.is_some() {
- let mut item_to_cgus = HashMap::new();
+ let mut item_to_cgus = FnvHashMap();
for cgu in &codegen_units {
for (&trans_item, &linkage) in cgu.items() {
use rustc::ty::subst::Substs;
use rustc::ty::FnSig;
use rustc::ty::{self, Ty};
+use rustc::util::nodemap::FnvHashMap;
use {CrateCtxt, require_same_types};
-use std::collections::{HashMap};
use syntax::abi::Abi;
use syntax::ast;
use syntax::parse::token;
return
}
- let mut structural_to_nomimal = HashMap::new();
+ let mut structural_to_nomimal = FnvHashMap();
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 HashMap<&'a intrinsics::Type, ty::Ty<'tcx>>,
+ structural_to_nominal: &mut FnvHashMap<&'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 syntax::ast;
use syntax_pos::{Span, DUMMY_SP};
use rustc::hir;
-use std::collections::HashSet;
use std::mem;
use std::ops::Deref;
use std::rc::Rc;
opt_simplified_steps: Option<Vec<ty::fast_reject::SimplifiedType>>,
inherent_candidates: Vec<Candidate<'tcx>>,
extension_candidates: Vec<Candidate<'tcx>>,
- impl_dups: HashSet<DefId>,
+ impl_dups: FnvHashSet<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: HashSet::new(),
+ impl_dups: FnvHashSet(),
import_id: None,
steps: Rc::new(steps),
opt_simplified_steps: opt_simplified_steps,
expr_id: ast::NodeId)
-> Result<(), MethodError<'tcx>>
{
- let mut duplicates = HashSet::new();
+ let mut duplicates = FnvHashSet();
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 = HashSet::new();
+ let mut duplicates = FnvHashSet();
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 TypeAndSubsts;
use lint;
use util::common::{block_query, ErrorReported, indenter, loop_query};
-use util::nodemap::{DefIdMap, FnvHashMap, NodeMap};
+use util::nodemap::{DefIdMap, FnvHashMap, FnvHashSet, NodeMap};
use std::cell::{Cell, Ref, RefCell};
-use std::collections::{HashSet};
use std::mem::replace;
use std::ops::Deref;
use syntax::abi::Abi;
.filter_map(|t| self.default(t).map(|d| (t, d)))
.collect();
- let mut unbound_tyvars = HashSet::new();
+ let mut unbound_tyvars = FnvHashSet();
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: &HashSet<Ty<'tcx>>,
+ unbound_vars: &FnvHashSet<Ty<'tcx>>,
default_map: &FnvHashMap<&Ty<'tcx>, type_variable::Default<'tcx>>,
conflict: Ty<'tcx>)
-> Option<type_variable::Default<'tcx>> {
use rustc::infer::TypeOrigin;
use rustc::traits;
use rustc::ty::{self, Ty, TyCtxt};
+use rustc::util::nodemap::FnvHashSet;
-use std::collections::HashSet;
use syntax::ast;
use syntax_pos::Span;
use errors::DiagnosticBuilder;
assert_eq!(ty_predicates.parent, None);
let variances = self.tcx().item_variances(item_def_id);
- let mut constrained_parameters: HashSet<_> =
+ let mut constrained_parameters: FnvHashSet<_> =
variances[ast_generics.lifetimes.len()..]
.iter().enumerate()
.filter(|&(_, &variance)| variance != ty::Bivariant)
fn reject_shadowing_type_parameters(tcx: TyCtxt, span: Span, generics: &ty::Generics) {
let parent = tcx.lookup_generics(generics.parent.unwrap());
- let impl_params: HashSet<_> = parent.types.iter().map(|tp| tp.name).collect();
+ let impl_params: FnvHashSet<_> = parent.types.iter().map(|tp| tp.name).collect();
for method_param in &generics.types {
if impl_params.contains(&method_param.name) {
use rscope::*;
use rustc::dep_graph::DepNode;
use util::common::{ErrorReported, MemoizationMap};
-use util::nodemap::{NodeMap, FnvHashMap};
+use util::nodemap::{NodeMap, FnvHashMap, FnvHashSet};
use {CrateCtxt, write_ty_to_tcx};
use rustc_const_math::ConstInt;
use std::cell::RefCell;
-use std::collections::HashSet;
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::rc::Rc;
{
let inline_bounds = from_bounds(ccx, param_bounds);
let where_bounds = from_predicates(ccx, param_id, &where_clause.predicates);
- let all_bounds: HashSet<_> = inline_bounds.into_iter()
- .chain(where_bounds)
- .collect();
+ let all_bounds: FnvHashSet<_> = 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: HashSet<_> =
+ let mut input_parameters: FnvHashSet<_> =
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: HashSet<_> =
+ let mut input_parameters: FnvHashSet<_> =
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: HashSet<_> = impl_items.iter()
+ let lifetimes_in_associated_types: FnvHashSet<_> = 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 std::collections::HashSet;
+use rustc::util::nodemap::FnvHashSet;
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub enum Parameter {
pub fn identify_constrained_type_params<'tcx>(predicates: &[ty::Predicate<'tcx>],
impl_trait_ref: Option<ty::TraitRef<'tcx>>,
- input_parameters: &mut HashSet<Parameter>)
+ input_parameters: &mut
FnvHashSet<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 HashSet<Parameter>)
+ input_parameters: &mut
FnvHashSet<Parameter>)
{
// The canonical way of doing the needed topological sort
// would be a DFS, but getting the graph and its ownership
projects / rust.git / commitdiff