Deprecate the FxHashMap() and FxHashSet() constructor function hack

Author: oli-obk

src/librustc/dep_graph/cgu_reuse_tracker.rs

@@ -51,8 +51,8 @@ pub struct CguReuseTracker {
 impl CguReuseTracker {
     pub fn new() -> CguReuseTracker {
         let data = TrackerData {
-            actual_reuse: FxHashMap(),
-            expected_reuse: FxHashMap(),
+            actual_reuse: FxHashMap::default(),
+            expected_reuse: FxHashMap::default(),
         };
 
         CguReuseTracker {

src/librustc/dep_graph/dep_tracking_map.rs

@@ -36,7 +36,7 @@ impl<M: DepTrackingMapConfig> DepTrackingMap<M> {
         DepTrackingMap {
             phantom: PhantomData,
             graph,
-            map: FxHashMap(),
+            map: FxHashMap::default(),
         }
     }
 }

src/librustc/dep_graph/graph.rs

@@ -101,11 +101,11 @@ impl DepGraph {
         DepGraph {
             data: Some(Lrc::new(DepGraphData {
                 previous_work_products: prev_work_products,
-                dep_node_debug: Lock::new(FxHashMap()),
+                dep_node_debug: Lock::new(FxHashMap::default()),
                 current: Lock::new(CurrentDepGraph::new()),
                 previous: prev_graph,
                 colors: Lock::new(DepNodeColorMap::new(prev_graph_node_count)),
-                loaded_from_cache: Lock::new(FxHashMap()),
+                loaded_from_cache: Lock::new(FxHashMap::default()),
             })),
             fingerprints: Lrc::new(Lock::new(fingerprints)),
         }
@@ -209,7 +209,7 @@ impl DepGraph {
             |key| OpenTask::Regular(Lock::new(RegularOpenTask {
                 node: key,
                 reads: SmallVec::new(),
-                read_set: FxHashSet(),
+                read_set: FxHashSet::default(),
             })),
             |data, key, task| data.borrow_mut().complete_task(key, task))
     }
@@ -353,7 +353,7 @@ impl DepGraph {
             let (result, open_task) = ty::tls::with_context(|icx| {
                 let task = OpenTask::Anon(Lock::new(AnonOpenTask {
                     reads: SmallVec::new(),
-                    read_set: FxHashSet(),
+                    read_set: FxHashSet::default(),
                 }));
 
                 let r = {
@@ -937,7 +937,7 @@ impl CurrentDepGraph {
         CurrentDepGraph {
             nodes: IndexVec::new(),
             edges: IndexVec::new(),
-            node_to_node_index: FxHashMap(),
+            node_to_node_index: FxHashMap::default(),
             anon_id_seed: stable_hasher.finish(),
             forbidden_edge,
             total_read_count: 0,

src/librustc/dep_graph/query.rs

@@ -25,7 +25,7 @@ impl DepGraphQuery {
                edges: &[(DepNode, DepNode)])
                -> DepGraphQuery {
         let mut graph = Graph::with_capacity(nodes.len(), edges.len());
-        let mut indices = FxHashMap();
+        let mut indices = FxHashMap::default();
         for node in nodes {
             indices.insert(node.clone(), graph.add_node(node.clone()));
         }

src/librustc/hir/map/definitions.rs

@@ -421,10 +421,10 @@ impl Definitions {
             node_to_def_index: NodeMap(),
             def_index_to_node: [vec![], vec![]],
             node_to_hir_id: IndexVec::new(),
-            parent_modules_of_macro_defs: FxHashMap(),
-            expansions_that_defined: FxHashMap(),
-            next_disambiguator: FxHashMap(),
-            def_index_to_span: FxHashMap(),
+            parent_modules_of_macro_defs: FxHashMap::default(),
+            expansions_that_defined: FxHashMap::default(),
+            next_disambiguator: FxHashMap::default(),
+            def_index_to_span: FxHashMap::default(),
         }
     }
 

src/librustc/hir/map/hir_id_validator.rs

@@ -51,7 +51,7 @@ impl<'a, 'hir: 'a> OuterVisitor<'a, 'hir> {
         HirIdValidator {
             hir_map,
             owner_def_index: None,
-            hir_ids_seen: FxHashMap(),
+            hir_ids_seen: FxHashMap::default(),
             errors: Vec::new(),
         }
     }

src/librustc/ich/hcx.rs

@@ -370,7 +370,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for Span {
             // recursing every time.
             thread_local! {
                 static CACHE: RefCell<FxHashMap<hygiene::Mark, u64>> =
-                    RefCell::new(FxHashMap());
+                    RefCell::new(FxHashMap::default());
             }
 
             let sub_hash: u64 = CACHE.with(|cache| {

src/librustc/ich/impls_ty.rs

@@ -32,7 +32,7 @@ for &'gcx ty::List<T>
                                           hasher: &mut StableHasher<W>) {
         thread_local! {
             static CACHE: RefCell<FxHashMap<(usize, usize), Fingerprint>> =
-                RefCell::new(FxHashMap());
+                RefCell::new(FxHashMap::default());
         }
 
         let hash = CACHE.with(|cache| {

src/librustc/infer/freshen.rs

@@ -62,7 +62,7 @@ impl<'a, 'gcx, 'tcx> TypeFreshener<'a, 'gcx, 'tcx> {
         TypeFreshener {
             infcx,
             freshen_count: 0,
-            freshen_map: FxHashMap(),
+            freshen_map: FxHashMap::default(),
         }
     }
 

src/librustc/infer/higher_ranked/mod.rs

@@ -553,7 +553,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         let escaping_types =
             self.type_variables.borrow_mut().types_escaping_snapshot(&snapshot.type_snapshot);
 
-        let mut escaping_region_vars = FxHashSet();
+        let mut escaping_region_vars = FxHashSet::default();
         for ty in &escaping_types {
             self.tcx.collect_regions(ty, &mut escaping_region_vars);
         }

src/librustc/infer/lexical_region_resolve/graphviz.rs

@@ -143,7 +143,7 @@ impl<'a, 'gcx, 'tcx> ConstraintGraph<'a, 'gcx, 'tcx> {
            map: &'a ConstraintMap<'tcx>)
            -> ConstraintGraph<'a, 'gcx, 'tcx> {
         let mut i = 0;
-        let mut node_ids = FxHashMap();
+        let mut node_ids = FxHashMap::default();
         {
             let mut add_node = |node| {
                 if let Vacant(e) = node_ids.entry(node) {
@@ -230,7 +230,7 @@ impl<'a, 'gcx, 'tcx> dot::GraphWalk<'a> for ConstraintGraph<'a, 'gcx, 'tcx> {
     type Node = Node;
     type Edge = Edge<'tcx>;
     fn nodes(&self) -> dot::Nodes<'_, Node> {
-        let mut set = FxHashSet();
+        let mut set = FxHashSet::default();
         for node in self.node_ids.keys() {
             set.insert(*node);
         }

src/librustc/infer/lexical_region_resolve/mod.rs

@@ -614,7 +614,7 @@ impl<'cx, 'gcx, 'tcx> LexicalResolver<'cx, 'gcx, 'tcx> {
             dup_found: bool,
         }
         let mut state = WalkState {
-            set: FxHashSet(),
+            set: FxHashSet::default(),
             stack: vec![orig_node_idx],
             result: Vec::new(),
             dup_found: false,

src/librustc/infer/mod.rs

@@ -534,7 +534,7 @@ impl<'a, 'gcx, 'tcx> InferCtxtBuilder<'a, 'gcx, 'tcx> {
                 lexical_region_resolutions: RefCell::new(None),
                 selection_cache: traits::SelectionCache::new(),
                 evaluation_cache: traits::EvaluationCache::new(),
-                reported_trait_errors: RefCell::new(FxHashMap()),
+                reported_trait_errors: RefCell::new(FxHashMap::default()),
                 tainted_by_errors_flag: Cell::new(false),
                 err_count_on_creation: tcx.sess.err_count(),
                 in_snapshot: Cell::new(false),

src/librustc/infer/region_constraints/mod.rs

@@ -345,8 +345,8 @@ impl<'tcx> RegionConstraintCollector<'tcx> {
         RegionConstraintCollector {
             var_infos: VarInfos::default(),
             data: RegionConstraintData::default(),
-            lubs: FxHashMap(),
-            glbs: FxHashMap(),
+            lubs: FxHashMap::default(),
+            glbs: FxHashMap::default(),
             bound_count: 0,
             undo_log: Vec::new(),
             unification_table: ut::UnificationTable::new(),

src/librustc/infer/region_constraints/taint.rs

@@ -18,7 +18,7 @@ pub(super) struct TaintSet<'tcx> {
 
 impl<'tcx> TaintSet<'tcx> {
     pub(super) fn new(directions: TaintDirections, initial_region: ty::Region<'tcx>) -> Self {
-        let mut regions = FxHashSet();
+        let mut regions = FxHashSet::default();
         regions.insert(initial_region);
         TaintSet {
             directions: directions,

src/librustc/lint/context.rs

@@ -159,9 +159,9 @@ impl LintStore {
             pre_expansion_passes: Some(vec![]),
             early_passes: Some(vec![]),
             late_passes: Some(vec![]),
-            by_name: FxHashMap(),
-            future_incompatible: FxHashMap(),
-            lint_groups: FxHashMap(),
+            by_name: FxHashMap::default(),
+            future_incompatible: FxHashMap::default(),
+            lint_groups: FxHashMap::default(),
         }
     }
 

src/librustc/lint/levels.rs

@@ -59,7 +59,7 @@ impl LintLevelSets {
 
     fn process_command_line(&mut self, sess: &Session) {
         let store = sess.lint_store.borrow();
-        let mut specs = FxHashMap();
+        let mut specs = FxHashMap::default();
         self.lint_cap = sess.opts.lint_cap.unwrap_or(Level::Forbid);
 
         for &(ref lint_name, level) in &sess.opts.lint_opts {
@@ -175,7 +175,7 @@ impl<'a> LintLevelsBuilder<'a> {
             sess,
             sets,
             cur: 0,
-            id_to_set: FxHashMap(),
+            id_to_set: FxHashMap::default(),
             warn_about_weird_lints: sess.buffered_lints.borrow().is_some(),
         }
     }
@@ -195,7 +195,7 @@ impl<'a> LintLevelsBuilder<'a> {
     ///
     /// Don't forget to call `pop`!
     pub fn push(&mut self, attrs: &[ast::Attribute]) -> BuilderPush {
-        let mut specs = FxHashMap();
+        let mut specs = FxHashMap::default();
         let store = self.sess.lint_store.borrow();
         let sess = self.sess;
         let bad_attr = |span| {

src/librustc/middle/dead.rs

@@ -131,7 +131,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
     }
 
     fn mark_live_symbols(&mut self) {
-        let mut scanned = FxHashSet();
+        let mut scanned = FxHashSet::default();
         while let Some(id) = self.worklist.pop() {
             if !scanned.insert(id) {
                 continue
@@ -429,7 +429,7 @@ fn find_live<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         worklist,
         tcx,
         tables: &ty::TypeckTables::empty(None),
-        live_symbols: box FxHashSet(),
+        live_symbols: box FxHashSet::default(),
         repr_has_repr_c: false,
         in_pat: false,
         inherited_pub_visibility: false,

src/librustc/middle/dependency_format.rs

@@ -94,7 +94,7 @@ pub enum Linkage {
 
 pub fn calculate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
     let sess = &tcx.sess;
-    let mut fmts = FxHashMap();
+    let mut fmts = FxHashMap::default();
     for &ty in sess.crate_types.borrow().iter() {
         let linkage = calculate_type(tcx, ty);
         verify_ok(tcx, &linkage);
@@ -170,7 +170,7 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         }
     }
 
-    let mut formats = FxHashMap();
+    let mut formats = FxHashMap::default();
 
     // 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

src/librustc/middle/lang_items.rs

@@ -155,7 +155,7 @@ impl<'a, 'v, 'tcx> ItemLikeVisitor<'v> for LanguageItemCollector<'a, 'tcx> {
 
 impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> {
     fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> LanguageItemCollector<'a, 'tcx> {
-        let mut item_refs = FxHashMap();
+        let mut item_refs = FxHashMap::default();
 
         $( item_refs.insert($name, ($variant as usize, $target)); )*
 

src/librustc/middle/lib_features.rs

@@ -31,8 +31,8 @@ pub struct LibFeatures {
 impl LibFeatures {
     fn new() -> LibFeatures {
         LibFeatures {
-            stable: FxHashMap(),
-            unstable: FxHashSet(),
+            stable: FxHashMap::default(),
+            unstable: FxHashSet::default(),
         }
     }
 

src/librustc/middle/reachable.rs

@@ -207,7 +207,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
 
     // Step 2: Mark all symbols that the symbols on the worklist touch.
     fn propagate(&mut self) {
-        let mut scanned = FxHashSet();
+        let mut scanned = FxHashSet::default();
         while let Some(search_item) = self.worklist.pop() {
             if !scanned.insert(search_item) {
                 continue

src/librustc/middle/region.rs

@@ -1257,7 +1257,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RegionResolutionVisitor<'a, 'tcx> {
 
         let outer_ec = mem::replace(&mut self.expr_and_pat_count, 0);
         let outer_cx = self.cx;
-        let outer_ts = mem::replace(&mut self.terminating_scopes, FxHashSet());
+        let outer_ts = mem::replace(&mut self.terminating_scopes, FxHashSet::default());
         self.terminating_scopes.insert(body.value.hir_id.local_id);
 
         if let Some(root_id) = self.cx.root_id {
@@ -1347,7 +1347,7 @@ fn region_scope_tree<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
                 parent: None,
                 var_parent: None,
             },
-            terminating_scopes: FxHashSet(),
+            terminating_scopes: FxHashSet::default(),
         };
 
         let body = tcx.hir.body(body_id);

src/librustc/middle/resolve_lifetime.rs

@@ -393,9 +393,9 @@ fn resolve_lifetimes<'tcx>(
     let named_region_map = krate(tcx);
 
     let mut rl = ResolveLifetimes {
-        defs: FxHashMap(),
-        late_bound: FxHashMap(),
-        object_lifetime_defaults: FxHashMap(),
+        defs: FxHashMap::default(),
+        late_bound: FxHashMap::default(),
+        object_lifetime_defaults: FxHashMap::default(),
     };
 
     for (k, v) in named_region_map.defs {
@@ -692,7 +692,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                 debug!("visit_ty: index = {}", index);
 
                 let mut elision = None;
-                let mut lifetimes = FxHashMap();
+                let mut lifetimes = FxHashMap::default();
                 let mut type_count = 0;
                 for param in &generics.params {
                     match param.kind {
@@ -2017,7 +2017,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                     map: self.map,
                     outer_index: ty::INNERMOST,
                     have_bound_regions: false,
-                    lifetimes: FxHashSet(),
+                    lifetimes: FxHashSet::default(),
                 };
                 gather.visit_ty(input);
 
@@ -2537,14 +2537,14 @@ fn insert_late_bound_lifetimes(
            decl, generics);
 
     let mut constrained_by_input = ConstrainedCollector {
-        regions: FxHashSet(),
+        regions: FxHashSet::default(),
     };
     for arg_ty in &decl.inputs {
         constrained_by_input.visit_ty(arg_ty);
     }
 
     let mut appears_in_output = AllCollector {
-        regions: FxHashSet(),
+        regions: FxHashSet::default(),
     };
     intravisit::walk_fn_ret_ty(&mut appears_in_output, &decl.output);
 
@@ -2556,7 +2556,7 @@ fn insert_late_bound_lifetimes(
     // 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: FxHashSet(),
+        regions: FxHashSet::default(),
     };
     appears_in_where_clause.visit_generics(generics);