rustc: remove {FxHash,Node,DefId,HirId,ItemLocal}{Map,Set} "constructor" fns.

src/librustc/hir/lowering.rs

@@ -244,9 +244,9 @@ pub fn lower_crate(
         loop_scopes: Vec::new(),
         is_in_loop_condition: false,
         anonymous_lifetime_mode: AnonymousLifetimeMode::PassThrough,
-        type_def_lifetime_params: DefIdMap(),
+        type_def_lifetime_params: Default::default(),
         current_hir_id_owner: vec![(CRATE_DEF_INDEX, 0)],
-        item_local_id_counters: NodeMap(),
+        item_local_id_counters: Default::default(),
         node_id_to_hir_id: IndexVec::new(),
         is_generator: false,
         is_in_trait_impl: false,
@@ -1168,7 +1168,7 @@ impl<'a> LoweringContext<'a> {
                             hir::TyKind::BareFn(P(hir::BareFnTy {
                                 generic_params: this.lower_generic_params(
                                     &f.generic_params,
-                                    &NodeMap(),
+                                    &NodeMap::default(),
                                     ImplTraitContext::disallowed(),
                                 ),
                                 unsafety: this.lower_unsafety(f.unsafety),
@@ -2467,7 +2467,7 @@ impl<'a> LoweringContext<'a> {
         // FIXME: This could probably be done with less rightward drift. Also looks like two control
         //        paths where report_error is called are also the only paths that advance to after
         //        the match statement, so the error reporting could probably just be moved there.
-        let mut add_bounds: NodeMap<Vec<_>> = NodeMap();
+        let mut add_bounds: NodeMap<Vec<_>> = Default::default();
         for pred in &generics.where_clause.predicates {
             if let WherePredicate::BoundPredicate(ref bound_pred) = *pred {
                 'next_bound: for bound in &bound_pred.bounds {
@@ -2552,7 +2552,7 @@ impl<'a> LoweringContext<'a> {
                         hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
                             bound_generic_params: this.lower_generic_params(
                                 bound_generic_params,
-                                &NodeMap(),
+                                &NodeMap::default(),
                                 ImplTraitContext::disallowed(),
                             ),
                             bounded_ty: this.lower_ty(bounded_ty, ImplTraitContext::disallowed()),
@@ -2636,8 +2636,11 @@ impl<'a> LoweringContext<'a> {
         p: &PolyTraitRef,
         mut itctx: ImplTraitContext<'_>,
     ) -> hir::PolyTraitRef {
-        let bound_generic_params =
+        let bound_generic_params = self.lower_generic_params(
-            self.lower_generic_params(&p.bound_generic_params, &NodeMap(), itctx.reborrow());
+            &p.bound_generic_params,
+            &NodeMap::default(),
+            itctx.reborrow(),
+        );
         let trait_ref = self.with_parent_impl_lifetime_defs(
             &bound_generic_params,
             |this| this.lower_trait_ref(&p.trait_ref, itctx),

src/librustc/hir/map/definitions.rs

@@ -418,7 +418,7 @@ impl Definitions {
                 index_to_key: [vec![], vec![]],
                 def_path_hashes: [vec![], vec![]],
             },
-            node_to_def_index: NodeMap(),
+            node_to_def_index: Default::default(),
             def_index_to_node: [vec![], vec![]],
             node_to_hir_id: IndexVec::new(),
             parent_modules_of_macro_defs: Default::default(),

src/librustc/infer/opaque_types/mod.rs

@@ -121,7 +121,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             parent_def_id,
             body_id,
             param_env,
-            opaque_types: DefIdMap(),
+            opaque_types: Default::default(),
             obligations: vec![],
         };
         let value = instantiator.instantiate_opaque_types_in_map(value);

src/librustc/lint/mod.rs

@@ -496,7 +496,7 @@ pub struct LintBuffer {
 
 impl LintBuffer {
     pub fn new() -> LintBuffer {
-        LintBuffer { map: NodeMap() }
+        LintBuffer { map: ::std::default::Default::default() }
     }
 
     pub fn add_lint(&mut self,

src/librustc/middle/liveness.rs

@@ -272,9 +272,9 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> {
             tcx,
             num_live_nodes: 0,
             num_vars: 0,
-            live_node_map: HirIdMap(),
+            live_node_map: HirIdMap::default(),
-            variable_map: HirIdMap(),
+            variable_map: HirIdMap::default(),
-            capture_info_map: NodeMap(),
+            capture_info_map: Default::default(),
             var_kinds: Vec::new(),
             lnks: Vec::new(),
         }
@@ -397,7 +397,7 @@ fn visit_fn<'a, 'tcx: 'a>(ir: &mut IrMaps<'a, 'tcx>,
 fn add_from_pat<'a, 'tcx>(ir: &mut IrMaps<'a, 'tcx>, pat: &P<hir::Pat>) {
     // For struct patterns, take note of which fields used shorthand
     // (`x` rather than `x: x`).
-    let mut shorthand_field_ids = HirIdSet();
+    let mut shorthand_field_ids = HirIdSet::default();
     let mut pats = VecDeque::new();
     pats.push_back(pat);
     while let Some(pat) = pats.pop_front() {
@@ -691,8 +691,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             s: specials,
             successors: vec![invalid_node(); num_live_nodes],
             rwu_table: RWUTable::new(num_live_nodes * num_vars),
-            break_ln: NodeMap(),
+            break_ln: Default::default(),
-            cont_ln: NodeMap(),
+            cont_ln: Default::default(),
         }
     }
 

src/librustc/middle/reachable.rs

@@ -408,7 +408,7 @@ fn reachable_set<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) ->
     let mut reachable_context = ReachableContext {
         tcx,
         tables: &ty::TypeckTables::empty(None),
-        reachable_symbols: NodeSet(),
+        reachable_symbols: Default::default(),
         worklist: Vec::new(),
         any_library,
     };

src/librustc/middle/resolve_lifetime.rs

@@ -425,8 +425,8 @@ fn resolve_lifetimes<'tcx>(
 fn krate<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> NamedRegionMap {
     let krate = tcx.hir.krate();
     let mut map = NamedRegionMap {
-        defs: NodeMap(),
+        defs: Default::default(),
-        late_bound: NodeSet(),
+        late_bound: Default::default(),
         object_lifetime_defaults: compute_object_lifetime_defaults(tcx),
     };
     {
@@ -437,8 +437,8 @@ fn krate<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> NamedRegionMap {
             trait_ref_hack: false,
             is_in_fn_syntax: false,
             labels_in_fn: vec![],
-            xcrate_object_lifetime_defaults: DefIdMap(),
+            xcrate_object_lifetime_defaults: Default::default(),
-            lifetime_uses: &mut DefIdMap(),
+            lifetime_uses: &mut Default::default(),
         };
         for (_, item) in &krate.items {
             visitor.visit_item(item);
@@ -1278,7 +1278,7 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body) {
 fn compute_object_lifetime_defaults(
     tcx: TyCtxt<'_, '_, '_>,
 ) -> NodeMap<Vec<ObjectLifetimeDefault>> {
-    let mut map = NodeMap();
+    let mut map = NodeMap::default();
     for item in tcx.hir.krate().items.values() {
         match item.node {
             hir::ItemKind::Struct(_, ref generics)
@@ -1432,7 +1432,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
         } = self;
         let labels_in_fn = replace(&mut self.labels_in_fn, vec![]);
         let xcrate_object_lifetime_defaults =
-            replace(&mut self.xcrate_object_lifetime_defaults, DefIdMap());
+            replace(&mut self.xcrate_object_lifetime_defaults, DefIdMap::default());
         let mut this = LifetimeContext {
             tcx: *tcx,
             map: map,

src/librustc/ty/context.rs

@@ -446,22 +446,22 @@ impl<'tcx> TypeckTables<'tcx> {
     pub fn empty(local_id_root: Option<DefId>) -> TypeckTables<'tcx> {
         TypeckTables {
             local_id_root,
-            type_dependent_defs: ItemLocalMap(),
+            type_dependent_defs: Default::default(),
-            field_indices: ItemLocalMap(),
+            field_indices: Default::default(),
-            user_provided_tys: ItemLocalMap(),
+            user_provided_tys: Default::default(),
             user_provided_sigs: Default::default(),
-            node_types: ItemLocalMap(),
+            node_types: Default::default(),
-            node_substs: ItemLocalMap(),
+            node_substs: Default::default(),
-            user_substs: ItemLocalMap(),
+            user_substs: Default::default(),
-            adjustments: ItemLocalMap(),
+            adjustments: Default::default(),
-            pat_binding_modes: ItemLocalMap(),
+            pat_binding_modes: Default::default(),
-            pat_adjustments: ItemLocalMap(),
+            pat_adjustments: Default::default(),
             upvar_capture_map: Default::default(),
-            closure_kind_origins: ItemLocalMap(),
+            closure_kind_origins: Default::default(),
-            liberated_fn_sigs: ItemLocalMap(),
+            liberated_fn_sigs: Default::default(),
-            fru_field_types: ItemLocalMap(),
+            fru_field_types: Default::default(),
-            cast_kinds: ItemLocalMap(),
+            cast_kinds: Default::default(),
-            used_trait_imports: Lrc::new(DefIdSet()),
+            used_trait_imports: Lrc::new(Default::default()),
             tainted_by_errors: false,
             free_region_map: Default::default(),
             concrete_existential_types: Default::default(),

src/librustc/util/nodemap.rs

@@ -10,8 +10,6 @@
 
 //! An efficient hash map for node IDs
 
-#![allow(non_snake_case)]
-
 use hir::def_id::DefId;
 use hir::{HirId, ItemLocalId};
 use syntax::ast;
@@ -22,9 +20,7 @@ pub use rustc_data_structures::fx::FxHashSet;
 macro_rules! define_id_collections {
     ($map_name:ident, $set_name:ident, $key:ty) => {
         pub type $map_name<T> = FxHashMap<$key, T>;
-        pub fn $map_name<T>() -> $map_name<T> { Default::default() }
         pub type $set_name = FxHashSet<$key>;
-        pub fn $set_name() -> $set_name { Default::default() }
     }
 }
 

src/librustc_codegen_llvm/debuginfo/mod.rs

@@ -106,7 +106,7 @@ impl<'a, 'tcx> CrateDebugContext<'a, 'tcx> {
             created_files: Default::default(),
             created_enum_disr_types: Default::default(),
             type_map: Default::default(),
-            namespace_map: RefCell::new(DefIdMap()),
+            namespace_map: RefCell::new(Default::default()),
             composite_types_completed: Default::default(),
         }
     }

src/librustc_codegen_ssa/back/symbol_export.rs

@@ -64,7 +64,7 @@ fn reachable_non_generics_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     assert_eq!(cnum, LOCAL_CRATE);
 
     if !tcx.sess.opts.output_types.should_codegen() {
-        return Lrc::new(DefIdMap())
+        return Lrc::new(Default::default())
     }
 
     // Check to see if this crate is a "special runtime crate". These
@@ -299,7 +299,7 @@ fn upstream_monomorphizations_provider<'a, 'tcx>(
 
     let cnums = tcx.all_crate_nums(LOCAL_CRATE);
 
-    let mut instances: DefIdMap<FxHashMap<_, _>> = DefIdMap();
+    let mut instances: DefIdMap<FxHashMap<_, _>> = Default::default();
 
     let cnum_stable_ids: IndexVec<CrateNum, Fingerprint> = {
         let mut cnum_stable_ids = IndexVec::from_elem_n(Fingerprint::ZERO,

src/librustc_data_structures/fx.rs

@@ -8,6 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub use rustc_hash::FxHashMap;
+pub use rustc_hash::{FxHasher, FxHashMap, FxHashSet};
-pub use rustc_hash::FxHashSet;
-pub use rustc_hash::FxHasher;

src/librustc_lint/builtin.rs

@@ -603,7 +603,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDebugImplementations {
         };
 
         if self.impling_types.is_none() {
-            let mut impls = NodeSet();
+            let mut impls = NodeSet::default();
             cx.tcx.for_each_impl(debug, |d| {
                 if let Some(ty_def) = cx.tcx.type_of(d).ty_adt_def() {
                     if let Some(node_id) = cx.tcx.hir.as_local_node_id(ty_def.did) {

src/librustc_metadata/cstore_impl.rs

@@ -316,7 +316,7 @@ pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {
             use std::collections::hash_map::Entry;
 
             assert_eq!(cnum, LOCAL_CRATE);
-            let mut visible_parent_map: DefIdMap<DefId> = DefIdMap();
+            let mut visible_parent_map: DefIdMap<DefId> = Default::default();
 
             // Issue 46112: We want the map to prefer the shortest
             // paths when reporting the path to an item. Therefore we

src/librustc_mir/build/mod.rs

@@ -829,7 +829,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                 1,
             ),
             upvar_decls,
-            var_indices: NodeMap(),
+            var_indices: Default::default(),
             unit_temp: None,
             cached_resume_block: None,
             cached_return_block: None,

src/librustc_mir/monomorphize/collector.rs

@@ -314,7 +314,7 @@ pub fn collect_crate_mono_items<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
         time(tcx.sess, "collecting mono items", || {
             par_iter(roots).for_each(|root| {
-                let mut recursion_depths = DefIdMap();
+                let mut recursion_depths = DefIdMap::default();
                 collect_items_rec(tcx,
                                 root,
                                 visited,

src/librustc_mir/transform/mod.rs

@@ -72,7 +72,7 @@ fn mir_keys<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, krate: CrateNum)
                       -> Lrc<DefIdSet> {
     assert_eq!(krate, LOCAL_CRATE);
 
-    let mut set = DefIdSet();
+    let mut set = DefIdSet::default();
 
     // All body-owners have MIR associated with them.
     set.extend(tcx.body_owners());

src/librustc_passes/rvalue_promotion.rs

@@ -84,10 +84,10 @@ fn rvalue_promotable_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         tables: &ty::TypeckTables::empty(None),
         in_fn: false,
         in_static: false,
-        mut_rvalue_borrows: NodeSet(),
+        mut_rvalue_borrows: Default::default(),
         param_env: ty::ParamEnv::empty(),
         identity_substs: Substs::empty(),
-        result: ItemLocalSet(),
+        result: ItemLocalSet::default(),
     };
 
     // `def_id` should be a `Body` owner

src/librustc_privacy/lib.rs

@@ -1761,7 +1761,7 @@ fn privacy_access_levels<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             tcx,
             access_levels: &visitor.access_levels,
             in_variant: false,
-            old_error_set: NodeSet(),
+            old_error_set: Default::default(),
         };
         intravisit::walk_crate(&mut visitor, krate);
 

src/librustc_resolve/check_unused.rs

@@ -162,7 +162,7 @@ pub fn check_crate(resolver: &mut Resolver, krate: &ast::Crate) {
 
     let mut visitor = UnusedImportCheckVisitor {
         resolver,
-        unused_imports: NodeMap(),
+        unused_imports: Default::default(),
         base_id: ast::DUMMY_NODE_ID,
         item_span: DUMMY_SP,
     };

src/librustc_resolve/lib.rs

@@ -1862,22 +1862,22 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
 
             primitive_type_table: PrimitiveTypeTable::new(),
 
-            def_map: NodeMap(),
+            def_map: Default::default(),
-            import_map: NodeMap(),
+            import_map: Default::default(),
-            freevars: NodeMap(),
+            freevars: Default::default(),
-            freevars_seen: NodeMap(),
+            freevars_seen: Default::default(),
             export_map: FxHashMap::default(),
-            trait_map: NodeMap(),
+            trait_map: Default::default(),
             module_map,
-            block_map: NodeMap(),
+            block_map: Default::default(),
             extern_module_map: FxHashMap::default(),
             binding_parent_modules: FxHashMap::default(),
 
             make_glob_map: make_glob_map == MakeGlobMap::Yes,
-            glob_map: NodeMap(),
+            glob_map: Default::default(),
 
             used_imports: FxHashSet::default(),
-            maybe_unused_trait_imports: NodeSet(),
+            maybe_unused_trait_imports: Default::default(),
             maybe_unused_extern_crates: Vec::new(),
 
             unused_labels: FxHashMap::default(),
@@ -1907,7 +1907,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
             name_already_seen: FxHashMap::default(),
             whitelisted_legacy_custom_derives: Vec::new(),
             potentially_unused_imports: Vec::new(),
-            struct_constructors: DefIdMap(),
+            struct_constructors: Default::default(),
             found_unresolved_macro: false,
             unused_macros: FxHashSet::default(),
             current_type_ascription: Vec::new(),

src/librustc_typeck/check/mod.rs

@@ -643,11 +643,11 @@ impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
             },
             infcx,
             fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
-            locals: RefCell::new(NodeMap()),
+            locals: RefCell::new(Default::default()),
-            deferred_call_resolutions: RefCell::new(DefIdMap()),
+            deferred_call_resolutions: RefCell::new(Default::default()),
             deferred_cast_checks: RefCell::new(Vec::new()),
             deferred_generator_interiors: RefCell::new(Vec::new()),
-            opaque_types: RefCell::new(DefIdMap()),
+            opaque_types: RefCell::new(Default::default()),
             implicit_region_bound,
             body_id,
         }
@@ -1986,7 +1986,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             has_errors: Cell::new(false),
             enclosing_breakables: RefCell::new(EnclosingBreakables {
                 stack: Vec::new(),
-                by_id: NodeMap(),
+                by_id: Default::default(),
             }),
             inh,
         }

src/librustc_typeck/check/writeback.rs

@@ -56,7 +56,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
 
         let used_trait_imports = mem::replace(
             &mut self.tables.borrow_mut().used_trait_imports,
-            Lrc::new(DefIdSet()),
+            Lrc::new(DefIdSet::default()),
         );
         debug!(
             "used_trait_imports({:?}) = {:?}",

src/librustc_typeck/check_unused.rs

@@ -24,7 +24,7 @@ use rustc::util::nodemap::DefIdSet;
 use rustc_data_structures::fx::FxHashMap;
 
 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    let mut used_trait_imports = DefIdSet();
+    let mut used_trait_imports = DefIdSet::default();
     for &body_id in tcx.hir.krate().bodies.keys() {
         let item_def_id = tcx.hir.body_owner_def_id(body_id);
         let imports = tcx.used_trait_imports(item_def_id);

src/librustc_typeck/coherence/inherent_impls.rs

@@ -38,7 +38,7 @@ pub fn crate_inherent_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let mut collect = InherentCollect {
         tcx,
         impls_map: CrateInherentImpls {
-            inherent_impls: DefIdMap()
+            inherent_impls: DefIdMap::default()
         }
     };
     krate.visit_all_item_likes(&mut collect);

src/librustc_typeck/variance/terms.rs

@@ -81,7 +81,7 @@ pub fn determine_parameters_to_be_inferred<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>
     let mut terms_cx = TermsContext {
         tcx,
         arena,
-        inferred_starts: NodeMap(),
+        inferred_starts: Default::default(),
         inferred_terms: vec![],
 
         lang_items: lang_items(tcx),

src/librustdoc/passes/strip_hidden.rs

@@ -25,7 +25,7 @@ pub const STRIP_HIDDEN: Pass =
 
 /// Strip items marked `#[doc(hidden)]`
 pub fn strip_hidden(krate: clean::Crate, _: &DocContext) -> clean::Crate {
-    let mut retained = DefIdSet();
+    let mut retained = DefIdSet::default();
 
     // strip all #[doc(hidden)] items
     let krate = {

src/librustdoc/passes/strip_private.rs

@@ -24,7 +24,7 @@ pub const STRIP_PRIVATE: Pass =
 /// crate, specified by the `xcrate` flag.
 pub fn strip_private(mut krate: clean::Crate, cx: &DocContext) -> clean::Crate {
     // This stripper collects all *retained* nodes.
-    let mut retained = DefIdSet();
+    let mut retained = DefIdSet::default();
     let access_levels = cx.renderinfo.borrow().access_levels.clone();
 
     // strip all private items