Don't generate a new NodeId for universal impl Trait

Author: oli-obk

src/librustc/hir/lowering.rs

@@ -1139,7 +1139,7 @@ impl<'a> LoweringContext<'a> {
                 }
                 hir::TyTraitObject(bounds, lifetime_bound)
             }
-            TyKind::ImplTrait(exist_ty_node_id, ref bounds) => {
+            TyKind::ImplTrait(def_node_id, ref bounds) => {
                 let span = t.span;
                 match itctx {
                     ImplTraitContext::Existential(fn_def_id, _, _) => {
@@ -1159,27 +1159,27 @@ impl<'a> LoweringContext<'a> {
                             .definitions()
                             .create_def_with_parent(
                             fn_def_id.index,
-                            exist_ty_node_id,
+                            def_node_id,
                             DefPathData::ExistentialImplTrait,
                             DefIndexAddressSpace::High,
                             Mark::root(),
                             exist_ty_span,
                         );
 
                         // the `t` is just for printing debug messages
-                        self.allocate_hir_id_counter(exist_ty_node_id, t);
+                        self.allocate_hir_id_counter(def_node_id, t);
 
-                        let hir_bounds = self.with_hir_id_owner(exist_ty_node_id, |lctx| {
+                        let hir_bounds = self.with_hir_id_owner(def_node_id, |lctx| {
                             lctx.lower_bounds(bounds, itctx)
                         });
 
                         let (path_params, params) = self.generics_from_impl_trait_bounds(
-                            exist_ty_node_id,
+                            def_node_id,
                             exist_ty_def_index,
                             &hir_bounds,
                         );
 
-                        self.with_hir_id_owner(exist_ty_node_id, |lctx| {
+                        self.with_hir_id_owner(def_node_id, |lctx| {
                             let exist_ty_item_kind = hir::ItemExistential(hir::ExistTy {
                                 generics: hir::Generics {
                                     params,
@@ -1192,7 +1192,7 @@ impl<'a> LoweringContext<'a> {
                                 bounds: hir_bounds,
                                 impl_trait_fn: Some(fn_def_id),
                             });
-                            let exist_ty_id = lctx.lower_node_id(exist_ty_node_id);
+                            let exist_ty_id = lctx.lower_node_id(def_node_id);
                             // Generate an `existential type Foo: Trait;` declaration
                             trace!("creating existential type with id {:#?}", exist_ty_id);
                             // Set the name to `impl Bound1 + Bound2`
@@ -1225,8 +1225,7 @@ impl<'a> LoweringContext<'a> {
                         })
                     }
                     ImplTraitContext::Universal(def_id, in_band_ty_params) => {
-                        let def_node_id = self.next_id().node_id;
-
+                        self.lower_node_id(def_node_id);
                         // Add a definition for the in-band TyParam
                         let def_index = self.resolver.definitions().create_def_with_parent(
                             def_id.index,

src/librustc/hir/map/collector.rs

@@ -221,23 +221,27 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         // Make sure that the DepNode of some node coincides with the HirId
         // owner of that node.
         if cfg!(debug_assertions) {
-            let hir_id_owner = self.definitions.node_to_hir_id(id).owner;
+            let hir_id = self.definitions.node_to_hir_id(id);
 
-            if hir_id_owner != self.current_dep_node_owner {
+            if hir_id.owner != self.current_dep_node_owner {
                 let node_str = match self.definitions.opt_def_index(id) {
                     Some(def_index) => {
                         self.definitions.def_path(def_index).to_string_no_crate()
                     }
                     None => format!("{:?}", node)
                 };
 
+                if hir_id == ::hir::DUMMY_HIR_ID {
+                    println!("Maybe you forgot to lower the node id {:?}?", id);
+                }
+
                 bug!("inconsistent DepNode for `{}`: \
                       current_dep_node_owner={}, hir_id.owner={}",
                     node_str,
                     self.definitions
                         .def_path(self.current_dep_node_owner)
                         .to_string_no_crate(),
-                    self.definitions.def_path(hir_id_owner).to_string_no_crate())
+                    self.definitions.def_path(hir_id.owner).to_string_no_crate())
             }
         }