diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index 12a0cc0d25508..eb8ee8c2c1838 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -18,9 +18,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         b: &Block,
         targeted_by_break: bool,
     ) -> hir::Block<'hir> {
-        let (stmts, expr) = self.lower_stmts(&b.stmts);
-        let rules = self.lower_block_check_mode(&b.rules);
         let hir_id = self.lower_node_id(b.id);
+        debug!("yukang lower_block_noalloc hir_id={:?}", hir_id);
+        let rules = self.lower_block_check_mode(&b.rules);
+        let (stmts, expr) = self.lower_stmts(&b.stmts);
+        if stmts.len() > 0 {
+            debug!("yukang lower_block_noalloc stmts={:?}", stmts);
+        } else {
+            debug!("yukang lower_block_noalloc stmts is empty");
+        }
         hir::Block { hir_id, stmts, expr, rules, span: self.lower_span(b.span), targeted_by_break }
     }
 
@@ -28,12 +34,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         &mut self,
         mut ast_stmts: &[Stmt],
     ) -> (&'hir [hir::Stmt<'hir>], Option<&'hir hir::Expr<'hir>>) {
+        debug!("yukang lower_stmts ast_stmts={:?}", ast_stmts);
         let mut stmts = SmallVec::<[hir::Stmt<'hir>; 8]>::new();
         let mut expr = None;
         while let [s, tail @ ..] = ast_stmts {
             match s.kind {
                 StmtKind::Local(ref local) => {
                     let hir_id = self.lower_node_id(s.id);
+                    debug!("yukang local hir_id={:?}", hir_id);
                     let local = self.lower_local(local);
                     self.alias_attrs(hir_id, local.hir_id);
                     let kind = hir::StmtKind::Local(local);
@@ -41,12 +49,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     stmts.push(hir::Stmt { hir_id, kind, span });
                 }
                 StmtKind::Item(ref it) => {
+                    let hir_id = self.lower_node_id(s.id);
                     stmts.extend(self.lower_item_ref(it).into_iter().enumerate().map(
-                        |(i, item_id)| {
-                            let hir_id = match i {
-                                0 => self.lower_node_id(s.id),
-                                _ => self.next_id(),
-                            };
+                        |(_i, item_id)| {
                             let kind = hir::StmtKind::Item(item_id);
                             let span = self.lower_span(s.span);
                             hir::Stmt { hir_id, kind, span }
@@ -54,11 +59,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     ));
                 }
                 StmtKind::Expr(ref e) => {
-                    let e = self.lower_expr(e);
                     if tail.is_empty() {
-                        expr = Some(e);
+                        expr = Some(self.lower_expr(e));
                     } else {
                         let hir_id = self.lower_node_id(s.id);
+                        debug!("yukang lower_stmts hir_id={:?}", hir_id);
+                        let e = self.lower_expr(e);
                         self.alias_attrs(hir_id, e.hir_id);
                         let kind = hir::StmtKind::Expr(e);
                         let span = self.lower_span(s.span);
@@ -66,8 +72,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     }
                 }
                 StmtKind::Semi(ref e) => {
-                    let e = self.lower_expr(e);
                     let hir_id = self.lower_node_id(s.id);
+                    let e = self.lower_expr(e);
                     self.alias_attrs(hir_id, e.hir_id);
                     let kind = hir::StmtKind::Semi(e);
                     let span = self.lower_span(s.span);
@@ -82,12 +88,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_local(&mut self, l: &Local) -> &'hir hir::Local<'hir> {
+        let hir_id = self.lower_node_id(l.id);
         let ty = l
             .ty
             .as_ref()
             .map(|t| self.lower_ty(t, &ImplTraitContext::Disallowed(ImplTraitPosition::Variable)));
         let init = l.kind.init().map(|init| self.lower_expr(init));
-        let hir_id = self.lower_node_id(l.id);
         let pat = self.lower_pat(&l.pat);
         let els = if let LocalKind::InitElse(_, els) = &l.kind {
             Some(self.lower_block(els, false))
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index eaa5a38388afc..07cd750130752 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -31,6 +31,36 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
         ensure_sufficient_stack(|| {
+            // Desugar `ExprForLoop`
+            // from: `[opt_ident]: for <pat> in <head> <body>`
+            if let ExprKind::ForLoop(ref pat, ref head, ref body, opt_label) = e.kind {
+                return self.lower_expr_for(e, pat, head, body, opt_label);
+            }
+
+            if let ExprKind::Paren(ref ex) = e.kind {
+                let mut ex = self.lower_expr_mut(ex);
+                // Include parens in span, but only if it is a super-span.
+                if e.span.contains(ex.span) {
+                    ex.span = self.lower_span(e.span);
+                }
+                // Merge attributes into the inner expression.
+                if !e.attrs.is_empty() {
+                    let old_attrs =
+                        self.attrs.get(&ex.hir_id.local_id).map(|la| *la).unwrap_or(&[]);
+                    self.attrs.insert(
+                        ex.hir_id.local_id,
+                        &*self.arena.alloc_from_iter(
+                            e.attrs
+                                .iter()
+                                .map(|a| self.lower_attr(a))
+                                .chain(old_attrs.iter().cloned()),
+                        ),
+                    );
+                }
+                return ex;
+            }
+
+            let hir_id = self.lower_node_id(e.id);
             let kind = match e.kind {
                 ExprKind::Box(ref inner) => hir::ExprKind::Box(self.lower_expr(inner)),
                 ExprKind::Array(ref exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
@@ -48,7 +78,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     if e.attrs.get(0).map_or(false, |a| a.has_name(sym::rustc_box)) {
                         if let [inner] = &args[..] && e.attrs.len() == 1 {
                             let kind = hir::ExprKind::Box(self.lower_expr(&inner));
-                            let hir_id = self.lower_node_id(e.id);
                             return hir::Expr { hir_id, kind, span: self.lower_span(e.span) };
                         } else {
                             self.tcx.sess.emit_err(RustcBoxAttributeError { span: e.span });
@@ -281,38 +310,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::Yield(ref opt_expr) => self.lower_expr_yield(e.span, opt_expr.as_deref()),
                 ExprKind::Err => hir::ExprKind::Err,
                 ExprKind::Try(ref sub_expr) => self.lower_expr_try(e.span, sub_expr),
-                ExprKind::Paren(ref ex) => {
-                    let mut ex = self.lower_expr_mut(ex);
-                    // Include parens in span, but only if it is a super-span.
-                    if e.span.contains(ex.span) {
-                        ex.span = self.lower_span(e.span);
-                    }
-                    // Merge attributes into the inner expression.
-                    if !e.attrs.is_empty() {
-                        let old_attrs =
-                            self.attrs.get(&ex.hir_id.local_id).map(|la| *la).unwrap_or(&[]);
-                        self.attrs.insert(
-                            ex.hir_id.local_id,
-                            &*self.arena.alloc_from_iter(
-                                e.attrs
-                                    .iter()
-                                    .map(|a| self.lower_attr(a))
-                                    .chain(old_attrs.iter().cloned()),
-                            ),
-                        );
-                    }
-                    return ex;
-                }
-
-                // Desugar `ExprForLoop`
-                // from: `[opt_ident]: for <pat> in <head> <body>`
-                ExprKind::ForLoop(ref pat, ref head, ref body, opt_label) => {
-                    return self.lower_expr_for(e, pat, head, body, opt_label);
-                }
-                ExprKind::MacCall(_) => panic!("{:?} shouldn't exist here", e.span),
+                ExprKind::MacCall(_) | _ => panic!("{:?} shouldn't exist here", e.span),
             };
 
-            let hir_id = self.lower_node_id(e.id);
+            //let hir_id = self.lower_node_id(e.id);
             self.lower_attrs(hir_id, &e.attrs);
             hir::Expr { hir_id, kind, span: self.lower_span(e.span) }
         })
@@ -434,11 +435,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
             ExprKind::Binary(op @ Spanned { node: ast::BinOpKind::And, .. }, lhs, rhs)
                 if has_let_expr(cond) =>
             {
+                let hir_id = self.next_id();
                 let op = self.lower_binop(*op);
                 let lhs = self.lower_cond(lhs);
                 let rhs = self.lower_cond(rhs);
-
-                self.arena.alloc(self.expr(
+                self.arena.alloc(self.expr_with_hirid(
+                    hir_id,
                     cond.span,
                     hir::ExprKind::Binary(op, lhs, rhs),
                     AttrVec::new(),
@@ -446,10 +448,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
             ExprKind::Let(..) => self.lower_expr(cond),
             _ => {
+                let hir_id = self.next_id();
                 let cond = self.lower_expr(cond);
                 let reason = DesugaringKind::CondTemporary;
                 let span_block = self.mark_span_with_reason(reason, cond.span, None);
-                self.expr_drop_temps(span_block, cond, AttrVec::new())
+                self.expr_drop_temps_with_hirid(hir_id, span_block, cond, AttrVec::new())
             }
         }
     }
@@ -477,15 +480,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Block,
         opt_label: Option<Label>,
     ) -> hir::ExprKind<'hir> {
+        let block_hir_id = self.next_id();
+        let if_hir_id = self.next_id();
         let lowered_cond = self.with_loop_condition_scope(|t| t.lower_cond(cond));
         let then = self.lower_block_expr(body);
-        let expr_break = self.expr_break(span, AttrVec::new());
-        let stmt_break = self.stmt_expr(span, expr_break);
-        let else_blk = self.block_all(span, arena_vec![self; stmt_break], None);
-        let else_expr = self.arena.alloc(self.expr_block(else_blk, AttrVec::new()));
+        let else_expr = self.arena.alloc(self.expr_block(
+            |this| {
+                let hir_id = this.next_id();
+                let stmt_hir_id = this.next_id();
+                let expr_break = this.expr_break(span, AttrVec::new());
+                let stmt_break = this.stmt_expr_with_hirid(stmt_hir_id, span, expr_break);
+                this.block_all_with_hirid(hir_id, span, arena_vec![self; stmt_break], None)
+            },
+            AttrVec::new(),
+        ));
         let if_kind = hir::ExprKind::If(lowered_cond, self.arena.alloc(then), Some(else_expr));
-        let if_expr = self.expr(span, if_kind, AttrVec::new());
-        let block = self.block_expr(self.arena.alloc(if_expr));
+        let if_expr = self.expr_with_hirid(if_hir_id, span, if_kind, AttrVec::new());
+        let block = self.block_expr_with_hirid(block_hir_id, self.arena.alloc(if_expr));
         let span = self.lower_span(span.with_hi(cond.span.hi()));
         let opt_label = self.lower_label(opt_label);
         hir::ExprKind::Loop(block, opt_label, hir::LoopSource::While, span)
@@ -550,6 +561,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_arm(&mut self, arm: &Arm) -> hir::Arm<'hir> {
+        let hir_id = self.next_id();
         let pat = self.lower_pat(&arm.pat);
         let guard = arm.guard.as_ref().map(|cond| {
             if let ExprKind::Let(ref pat, ref scrutinee, span) = cond.kind {
@@ -564,7 +576,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir::Guard::If(self.lower_expr(cond))
             }
         });
-        let hir_id = self.next_id();
+
         self.lower_attrs(hir_id, &arm.attrs);
         hir::Arm {
             hir_id,
@@ -593,6 +605,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         async_gen_kind: hir::AsyncGeneratorKind,
         body: impl FnOnce(&mut Self) -> hir::Expr<'hir>,
     ) -> hir::ExprKind<'hir> {
+        let generator_hir_id = self.lower_node_id(closure_node_id);
+
         let output = match ret_ty {
             Some(ty) => hir::FnRetTy::Return(
                 self.lower_ty(&ty, &ImplTraitContext::Disallowed(ImplTraitPosition::AsyncBlock)),
@@ -664,7 +678,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
             self.mark_span_with_reason(DesugaringKind::Async, span, self.allow_gen_future.clone());
 
         let hir_id = if parent_has_track_caller {
-            let generator_hir_id = self.lower_node_id(closure_node_id);
             self.lower_attrs(
                 generator_hir_id,
                 &[Attribute {
@@ -738,6 +751,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // Note that the name of this binding must not be changed to something else because
         // debuggers and debugger extensions expect it to be called `__awaitee`. They use
         // this name to identify what is being awaited by a suspended async functions.
+        let expr_ident_hir_id = self.next_id();
         let awaitee_ident = Ident::with_dummy_span(sym::__awaitee);
         let (awaitee_pat, awaitee_pat_hid) =
             self.pat_ident_binding_mode(span, awaitee_ident, hir::BindingAnnotation::MUT);
@@ -751,10 +765,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         //     )
         // }
         let poll_expr = {
-            let awaitee = self.expr_ident(span, awaitee_ident, awaitee_pat_hid);
+            let awaitee = self.expr_ident(expr_ident_hir_id, span, awaitee_ident, awaitee_pat_hid);
             let ref_mut_awaitee = self.expr_mut_addr_of(span, awaitee);
             let task_context = if let Some(task_context_hid) = self.task_context {
-                self.expr_ident_mut(span, task_context_ident, task_context_hid)
+                let ident_mut_hir_id = self.next_id();
+                self.expr_ident_mut(ident_mut_hir_id, span, task_context_ident, task_context_hid)
             } else {
                 // Use of `await` outside of an async context, we cannot use `task_context` here.
                 self.expr_err(span)
@@ -783,6 +798,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // `::std::task::Poll::Ready(result) => break result`
         let loop_node_id = self.next_node_id();
         let loop_hir_id = self.lower_node_id(loop_node_id);
+        let block_hir_id = self.next_id();
         let ready_arm = {
             let x_ident = Ident::with_dummy_span(sym::result);
             let (x_pat, x_pat_hid) = self.pat_ident(gen_future_span, x_ident);
@@ -815,17 +831,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
         };
 
         let inner_match_stmt = {
+            let stmt_hir_id = self.next_id();
             let match_expr = self.expr_match(
                 span,
                 poll_expr,
                 arena_vec![self; ready_arm, pending_arm],
                 hir::MatchSource::AwaitDesugar,
             );
-            self.stmt_expr(span, match_expr)
+            self.stmt_expr_with_hirid(stmt_hir_id, span, match_expr)
         };
 
         // task_context = yield ();
         let yield_stmt = {
+            let stmt_hir_id = self.next_id();
             let unit = self.expr_unit(span);
             let yield_expr = self.expr(
                 span,
@@ -841,15 +859,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::ExprKind::Assign(lhs, yield_expr, self.lower_span(span)),
                     AttrVec::new(),
                 );
-                self.stmt_expr(span, assign)
+                self.stmt_expr_with_hirid(stmt_hir_id, span, assign)
             } else {
                 // Use of `await` outside of an async context. Return `yield_expr` so that we can
                 // proceed with type checking.
-                self.stmt(span, hir::StmtKind::Semi(yield_expr))
+                self.stmt(stmt_hir_id, span, hir::StmtKind::Semi(yield_expr))
             }
         };
 
-        let loop_block = self.block_all(span, arena_vec![self; inner_match_stmt, yield_stmt], None);
+        let loop_block = self.block_all_with_hirid(
+            block_hir_id,
+            span,
+            arena_vec![self; inner_match_stmt, yield_stmt],
+            None,
+        );
 
         // loop { .. }
         let loop_expr = self.arena.alloc(hir::Expr {
@@ -1075,6 +1098,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
 
         let mut assignments = vec![];
+        let block_hir_id = self.next_id();
 
         // The LHS becomes a pattern: `(lhs1, lhs2)`.
         let pat = self.destructure_assign(lhs, eq_sign_span, &mut assignments);
@@ -1095,7 +1119,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             .alloc_from_iter(std::iter::once(destructure_let).chain(assignments.into_iter()));
 
         // Wrap everything in a block.
-        hir::ExprKind::Block(&self.block_all(whole_span, stmts, None), None)
+        hir::ExprKind::Block(
+            &self.block_all_with_hirid(block_hir_id, whole_span, stmts, None),
+            None,
+        )
     }
 
     /// If the given expression is a path to a tuple struct, returns that path.
@@ -1162,6 +1189,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
             // Slice patterns.
             ExprKind::Array(elements) => {
+                let hir_id = self.next_id();
                 let (pats, rest) =
                     self.destructure_sequence(elements, "slice", eq_sign_span, assignments);
                 let slice_pat = if let Some((i, span)) = rest {
@@ -1174,11 +1202,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 } else {
                     hir::PatKind::Slice(pats, None, &[])
                 };
-                return self.pat_without_dbm(lhs.span, slice_pat);
+                return self.pat_without_dbm_with_hirid(hir_id, lhs.span, slice_pat);
             }
             // Tuple structs.
             ExprKind::Call(callee, args) => {
                 if let Some((qself, path)) = self.extract_tuple_struct_path(callee) {
+                    let hir_id = self.next_id();
+
                     let (pats, rest) = self.destructure_sequence(
                         args,
                         "tuple struct or variant",
@@ -1198,12 +1228,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         pats,
                         hir::DotDotPos::new(rest.map(|r| r.0)),
                     );
-                    return self.pat_without_dbm(lhs.span, tuple_struct_pat);
+                    return self.pat_without_dbm_with_hirid(hir_id, lhs.span, tuple_struct_pat);
                 }
             }
             // Unit structs and enum variants.
             ExprKind::Path(..) => {
                 if let Some((qself, path)) = self.extract_unit_struct_path(lhs) {
+                    let hir_id = self.next_id();
                     let qpath = self.lower_qpath(
                         lhs.id,
                         qself,
@@ -1213,15 +1244,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     );
                     // Destructure like a unit struct.
                     let unit_struct_pat = hir::PatKind::Path(qpath);
-                    return self.pat_without_dbm(lhs.span, unit_struct_pat);
+                    return self.pat_without_dbm_with_hirid(hir_id, lhs.span, unit_struct_pat);
                 }
             }
             // Structs.
             ExprKind::Struct(se) => {
+                let hir_id = self.next_id();
                 let field_pats = self.arena.alloc_from_iter(se.fields.iter().map(|f| {
+                    let hir_id = self.next_id();
                     let pat = self.destructure_assign(&f.expr, eq_sign_span, assignments);
                     hir::PatField {
-                        hir_id: self.next_id(),
+                        hir_id,
                         ident: self.lower_ident(f.ident),
                         pat,
                         is_shorthand: f.is_shorthand,
@@ -1246,20 +1279,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     StructRest::None => false,
                 };
                 let struct_pat = hir::PatKind::Struct(qpath, field_pats, fields_omitted);
-                return self.pat_without_dbm(lhs.span, struct_pat);
+                return self.pat_without_dbm_with_hirid(hir_id, lhs.span, struct_pat);
             }
             // Tuples.
             ExprKind::Tup(elements) => {
+                let hir_id = self.next_id();
                 let (pats, rest) =
                     self.destructure_sequence(elements, "tuple", eq_sign_span, assignments);
                 let tuple_pat = hir::PatKind::Tuple(pats, hir::DotDotPos::new(rest.map(|r| r.0)));
-                return self.pat_without_dbm(lhs.span, tuple_pat);
+                return self.pat_without_dbm_with_hirid(hir_id, lhs.span, tuple_pat);
             }
             ExprKind::Paren(e) => {
+                let hir_id = self.next_id();
                 // We special-case `(..)` for consistency with patterns.
                 if let ExprKind::Range(None, None, RangeLimits::HalfOpen) = e.kind {
                     let tuple_pat = hir::PatKind::Tuple(&[], hir::DotDotPos::new(Some(0)));
-                    return self.pat_without_dbm(lhs.span, tuple_pat);
+                    return self.pat_without_dbm_with_hirid(hir_id, lhs.span, tuple_pat);
                 } else {
                     return self.destructure_assign_mut(e, eq_sign_span, assignments);
                 }
@@ -1267,13 +1302,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
             _ => {}
         }
         // Treat all other cases as normal lvalue.
+        let stmt_hir_id = self.next_id();
+        let expr_hir_id = self.next_id();
         let ident = Ident::new(sym::lhs, self.lower_span(lhs.span));
         let (pat, binding) = self.pat_ident_mut(lhs.span, ident);
         let ident = self.expr_ident(lhs.span, ident, binding);
         let assign =
             hir::ExprKind::Assign(self.lower_expr(lhs), ident, self.lower_span(eq_sign_span));
-        let expr = self.expr(lhs.span, assign, AttrVec::new());
-        assignments.push(self.stmt_expr(lhs.span, expr));
+        let expr = self.expr_with_hirid(expr_hir_id, lhs.span, assign, AttrVec::new());
+        assignments.push(self.stmt_expr_with_hirid(stmt_hir_id, lhs.span, expr));
         pat
     }
 
@@ -1477,6 +1514,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Block,
         opt_label: Option<Label>,
     ) -> hir::Expr<'hir> {
+        let drop_temps_hir_id = self.next_id();
+        let loop_hir_id = self.lower_node_id(e.id);
+        let block_hir_id = self.next_id();
+        let stmt_hir_id = self.next_id();
+
         let head = self.lower_expr_mut(head);
         let pat = self.lower_pat(pat);
         let for_span =
@@ -1495,8 +1537,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // Some(<pat>) => <body>,
         let some_arm = {
             let some_pat = self.pat_some(pat_span, pat);
-            let body_block = self.with_loop_scope(e.id, |this| this.lower_block(body, false));
-            let body_expr = self.arena.alloc(self.expr_block(body_block, AttrVec::new()));
+            //let body_block = || self.with_loop_scope(e.id, |this| this.lower_block(body, false));
+            let body_expr = self.arena.alloc(self.expr_block(
+                |this| this.with_loop_scope(e.id, |this| this.lower_block(body, false)),
+                AttrVec::new(),
+            ));
             self.arm(some_pat, body_expr)
         };
 
@@ -1519,9 +1564,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
             self.expr_match(head_span, next_expr, arms, hir::MatchSource::ForLoopDesugar)
         };
-        let match_stmt = self.stmt_expr(for_span, match_expr);
+        let match_stmt = self.stmt_expr_with_hirid(stmt_hir_id, for_span, match_expr);
 
-        let loop_block = self.block_all(for_span, arena_vec![self; match_stmt], None);
+        let loop_block =
+            self.block_all_with_hirid(block_hir_id, for_span, arena_vec![self; match_stmt], None);
 
         // `[opt_ident]: loop { ... }`
         let kind = hir::ExprKind::Loop(
@@ -1530,8 +1576,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             hir::LoopSource::ForLoop,
             self.lower_span(for_span.with_hi(head.span.hi())),
         );
-        let loop_expr =
-            self.arena.alloc(hir::Expr { hir_id: self.lower_node_id(e.id), kind, span: for_span });
+        let loop_expr = self.arena.alloc(hir::Expr { hir_id: loop_hir_id, kind, span: for_span });
 
         // `mut iter => { ... }`
         let iter_arm = self.arm(iter_pat, loop_expr);
@@ -1559,7 +1604,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // surrounding scope of the `match` since the `match` is not a terminating scope.
         //
         // Also, add the attributes to the outer returned expr node.
-        self.expr_drop_temps_mut(for_span, match_expr, e.attrs.clone())
+        self.expr_drop_temps_mut_with_hirid(
+            drop_temps_hir_id,
+            for_span,
+            match_expr,
+            e.attrs.clone(),
+        )
     }
 
     /// Desugar `ExprKind::Try` from: `<expr>?` into:
@@ -1616,8 +1666,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // `ControlFlow::Continue(val) => #[allow(unreachable_code)] val,`
         let continue_arm = {
             let val_ident = Ident::with_dummy_span(sym::val);
+            let hir_id = self.next_id();
             let (val_pat, val_pat_nid) = self.pat_ident(span, val_ident);
-            let val_expr = self.arena.alloc(self.expr_ident_with_attrs(
+            let val_expr = self.arena.alloc(self.expr_ident_with_attrs_with_hirid(
+                hir_id,
                 span,
                 val_ident,
                 val_pat_nid,
@@ -1717,24 +1769,44 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// `{ let _t = $expr; _t }` but should provide better compile-time performance.
     ///
     /// The drop order can be important in e.g. `if expr { .. }`.
-    pub(super) fn expr_drop_temps(
+    pub(super) fn expr_drop_temps_with_hirid(
         &mut self,
+        hir_id: hir::HirId,
         span: Span,
         expr: &'hir hir::Expr<'hir>,
         attrs: AttrVec,
     ) -> &'hir hir::Expr<'hir> {
-        self.arena.alloc(self.expr_drop_temps_mut(span, expr, attrs))
+        self.arena.alloc(self.expr_drop_temps_mut_with_hirid(hir_id, span, expr, attrs))
     }
 
-    pub(super) fn expr_drop_temps_mut(
+    pub(super) fn expr_drop_temps_mut_with_hirid(
         &mut self,
+        hir_id: hir::HirId,
         span: Span,
         expr: &'hir hir::Expr<'hir>,
         attrs: AttrVec,
     ) -> hir::Expr<'hir> {
-        self.expr(span, hir::ExprKind::DropTemps(expr), attrs)
+        self.expr_with_hirid(hir_id, span, hir::ExprKind::DropTemps(expr), attrs)
     }
 
+    /*   pub(super) fn expr_drop_temps(
+        &mut self,
+        span: Span,
+        expr: &'hir hir::Expr<'hir>,
+        attrs: AttrVec,
+    ) -> &'hir hir::Expr<'hir> {
+        self.arena.alloc(self.expr_drop_temps_mut(span, expr, attrs))
+    } */
+
+    /*     pub(super) fn expr_drop_temps_mut(
+        &mut self,
+        span: Span,
+        expr: &'hir hir::Expr<'hir>,
+        attrs: AttrVec,
+    ) -> hir::Expr<'hir> {
+        self.expr(span, hir::ExprKind::DropTemps(expr), attrs)
+    } */
+
     fn expr_match(
         &mut self,
         span: Span,
@@ -1769,24 +1841,27 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn expr_call_mut(
         &mut self,
+        hir_id: hir::HirId,
         span: Span,
         e: &'hir hir::Expr<'hir>,
         args: &'hir [hir::Expr<'hir>],
     ) -> hir::Expr<'hir> {
-        self.expr(span, hir::ExprKind::Call(e, args), AttrVec::new())
+        self.expr_with_hirid(hir_id, span, hir::ExprKind::Call(e, args), AttrVec::new())
     }
 
     fn expr_call(
         &mut self,
+        hir_id: hir::HirId,
         span: Span,
         e: &'hir hir::Expr<'hir>,
         args: &'hir [hir::Expr<'hir>],
     ) -> &'hir hir::Expr<'hir> {
-        self.arena.alloc(self.expr_call_mut(span, e, args))
+        self.arena.alloc(self.expr_call_mut(hir_id, span, e, args))
     }
 
     fn expr_call_lang_item_fn_mut(
         &mut self,
+        fn_mut_hir_id: hir::HirId,
         span: Span,
         lang_item: hir::LangItem,
         args: &'hir [hir::Expr<'hir>],
@@ -1794,7 +1869,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::Expr<'hir> {
         let path =
             self.arena.alloc(self.expr_lang_item_path(span, lang_item, AttrVec::new(), hir_id));
-        self.expr_call_mut(span, path, args)
+        self.expr_call_mut(fn_mut_hir_id, span, path, args)
     }
 
     fn expr_call_lang_item_fn(
@@ -1823,45 +1898,47 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     pub(super) fn expr_ident(
         &mut self,
+        hir_id: hir::HirId,
         sp: Span,
         ident: Ident,
         binding: hir::HirId,
     ) -> &'hir hir::Expr<'hir> {
-        self.arena.alloc(self.expr_ident_mut(sp, ident, binding))
+        self.arena.alloc(self.expr_ident_mut(hir_id, sp, ident, binding))
     }
 
     pub(super) fn expr_ident_mut(
         &mut self,
+        hir_id: hir::HirId,
         sp: Span,
         ident: Ident,
         binding: hir::HirId,
     ) -> hir::Expr<'hir> {
-        self.expr_ident_with_attrs(sp, ident, binding, AttrVec::new())
+        self.expr_ident_with_attrs_hirid(hir_id, sp, ident, binding, AttrVec::new())
     }
 
-    fn expr_ident_with_attrs(
+    fn expr_ident_with_attrs_with_hirid(
         &mut self,
+        hir_id: hir::HirId,
         span: Span,
         ident: Ident,
         binding: hir::HirId,
         attrs: AttrVec,
     ) -> hir::Expr<'hir> {
-        let hir_id = self.next_id();
+        let path_hir_id = self.next_id();
         let res = Res::Local(binding);
         let expr_path = hir::ExprKind::Path(hir::QPath::Resolved(
             None,
             self.arena.alloc(hir::Path {
                 span: self.lower_span(span),
                 res,
-                segments: arena_vec![self; hir::PathSegment::new(ident, hir_id, res)],
+                segments: arena_vec![self; hir::PathSegment::new(ident, path_hir_id, res)],
             }),
         ));
 
-        self.expr(span, expr_path, attrs)
+        self.expr_with_hirid(hir_id, span, expr_path, attrs)
     }
 
-    fn expr_unsafe(&mut self, expr: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> {
-        let hir_id = self.next_id();
+    fn expr_unsafe(&mut self, hir_id: hir::HirId, expr: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> {
         let span = expr.span;
         self.expr(
             span,
@@ -1881,17 +1958,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn expr_block_empty(&mut self, span: Span) -> &'hir hir::Expr<'hir> {
-        let blk = self.block_all(span, &[], None);
-        let expr = self.expr_block(blk, AttrVec::new());
+        //let blk = || self.block_all(span, &[], None);
+        let expr = self.expr_block(|this| this.block_all(span, &[], None), AttrVec::new());
         self.arena.alloc(expr)
     }
 
     pub(super) fn expr_block(
         &mut self,
-        b: &'hir hir::Block<'hir>,
+        //b: &'hir hir::Block<'hir>,
+        gen_block: impl FnOnce(&mut Self) -> &'hir hir::Block<'hir>,
         attrs: AttrVec,
     ) -> hir::Expr<'hir> {
-        self.expr(b.span, hir::ExprKind::Block(b, None), attrs)
+        let hir_id = self.next_id();
+        debug!("yuakng expr hir_id: {:?}", hir_id);
+        self.lower_attrs(hir_id, &attrs);
+        let b = gen_block(self);
+        hir::Expr { hir_id, kind: hir::ExprKind::Block(b, None), span: self.lower_span(b.span) }
+        //self.expr(b.span, hir::ExprKind::Block(b, None), attrs)
     }
 
     pub(super) fn expr(
@@ -1900,33 +1983,42 @@ impl<'hir> LoweringContext<'_, 'hir> {
         kind: hir::ExprKind<'hir>,
         attrs: AttrVec,
     ) -> hir::Expr<'hir> {
+        debug!("yukang expr({:?}, {:?})", span, kind);
         let hir_id = self.next_id();
+        debug!("yuakng expr hir_id: {:?}", hir_id);
+        self.lower_attrs(hir_id, &attrs);
+        hir::Expr { hir_id, kind, span: self.lower_span(span) }
+    }
+
+    pub(super) fn expr_with_hirid(
+        &mut self,
+        hir_id: hir::HirId,
+        span: Span,
+        kind: hir::ExprKind<'hir>,
+        attrs: AttrVec,
+    ) -> hir::Expr<'hir> {
+        debug!("yukang expr_with_hirid ({:?}, {:?})", span, kind);
+        debug!("yuakng expr hir_id: {:?}", hir_id);
         self.lower_attrs(hir_id, &attrs);
         hir::Expr { hir_id, kind, span: self.lower_span(span) }
     }
 
     fn expr_field(
         &mut self,
+        hir_id: hir::HirId,
         ident: Ident,
         expr: &'hir hir::Expr<'hir>,
         span: Span,
     ) -> hir::ExprField<'hir> {
-        hir::ExprField {
-            hir_id: self.next_id(),
-            ident,
-            span: self.lower_span(span),
-            expr,
-            is_shorthand: false,
-        }
+        hir::ExprField { hir_id, ident, span: self.lower_span(span), expr, is_shorthand: false }
     }
 
-    fn arm(&mut self, pat: &'hir hir::Pat<'hir>, expr: &'hir hir::Expr<'hir>) -> hir::Arm<'hir> {
-        hir::Arm {
-            hir_id: self.next_id(),
-            pat,
-            guard: None,
-            span: self.lower_span(expr.span),
-            body: expr,
-        }
+    fn arm(
+        &mut self,
+        hir_id: hir::HirId,
+        pat: &'hir hir::Pat<'hir>,
+        expr: &'hir hir::Expr<'hir>,
+    ) -> hir::Arm<'hir> {
+        hir::Arm { hir_id, pat, guard: None, span: self.lower_span(expr.span), body: expr }
     }
 }
diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
index 3a0e5f55ec1e4..e5dfea83b8ada 100644
--- a/compiler/rustc_ast_lowering/src/index.rs
+++ b/compiler/rustc_ast_lowering/src/index.rs
@@ -70,6 +70,16 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         debug_assert_eq!(self.owner, hir_id.owner);
         debug_assert_ne!(hir_id.local_id.as_u32(), 0);
         debug_assert_ne!(hir_id.local_id, self.parent_node);
+        let debug_log = std::env::var("RUSTC_HIR").is_ok();
+        if debug_log {
+            if hir_id.local_id < self.parent_node {
+                let message = format!(
+                    "HirIdValidator: The parent local_id: {:?} is not smaller than children id: {:?}",
+                    self.parent_node, hir_id.local_id
+                );
+                span_bug!(rustc_span::DUMMY_SP, "error NodeCollector.insert: {}", message);
+            }
+        }
 
         // Make sure that the DepNode of some node coincides with the HirId
         // owner of that node.
@@ -89,7 +99,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
             }
         }
 
-        self.nodes.insert(hir_id.local_id, ParentedNode { parent: self.parent_node, node: node });
+        self.nodes.insert(hir_id.local_id, ParentedNode { parent: self.parent_node, node });
     }
 
     fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_node_id: HirId, f: F) {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 05022c1a14c70..e3270a3d89ed5 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -270,7 +270,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let asyncness = header.asyncness;
                     let body_id =
                         this.lower_maybe_async_body(span, &decl, asyncness, body.as_deref());
-
+                    debug!("yukang finished lower_maybe_async_body");
                     let mut itctx = ImplTraitContext::Universal;
                     let (generics, decl) = this.lower_generics(generics, id, &mut itctx, |this| {
                         let ret_id = asyncness.opt_return_id();
@@ -751,6 +751,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> hir::FieldDef<'hir> {
+        let hir_id = self.lower_node_id(f.id);
         let ty = if let TyKind::Path(ref qself, ref path) = f.ty.kind {
             let t = self.lower_path_ty(
                 &f.ty,
@@ -763,7 +764,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         } else {
             self.lower_ty(&f.ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Type))
         };
-        let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs);
         hir::FieldDef {
             span: self.lower_span(f.span),
@@ -882,6 +882,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
         // Since `default impl` is not yet implemented, this is always true in impls.
+        let hir_id = self.lower_node_id(i.id);
         let has_value = true;
         let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
 
@@ -930,7 +931,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
             AssocItemKind::MacCall(..) => panic!("`TyMac` should have been expanded by now"),
         };
 
-        let hir_id = self.lower_node_id(i.id);
         self.lower_attrs(hir_id, &i.attrs);
         let item = hir::ImplItem {
             owner_id: hir_id.expect_owner(),
@@ -1072,10 +1072,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
             (Async::Yes { closure_id, .. }, Some(body)) => (closure_id, body),
             _ => return self.lower_fn_body_block(span, decl, body),
         };
-
+        debug!("yukang continue Lower");
         self.lower_body(|this| {
             let mut parameters: Vec<hir::Param<'_>> = Vec::new();
             let mut statements: Vec<hir::Stmt<'_>> = Vec::new();
+            let expr_hirid = this.next_id();
+            //let block_hirid = this.next_id();
 
             // Async function parameters are lowered into the closure body so that they are
             // captured and so that the drop order matches the equivalent non-async functions.
@@ -1143,6 +1145,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 // If this is the simple case, this parameter will end up being the same as the
                 // original parameter, but with a different pattern id.
                 let stmt_attrs = this.attrs.get(&parameter.hir_id.local_id).copied();
+                let expr_ident_hir_id = this.next_id();
                 let (new_parameter_pat, new_parameter_id) = this.pat_ident(desugared_span, ident);
                 let new_parameter = hir::Param {
                     hir_id: parameter.hir_id,
@@ -1155,7 +1158,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     // If this is the simple case, then we only insert one statement that is
                     // `let <pat> = <pat>;`. We re-use the original argument's pattern so that
                     // `HirId`s are densely assigned.
-                    let expr = this.expr_ident(desugared_span, ident, new_parameter_id);
+                    let expr =
+                        this.expr_ident(expr_ident_hir_id, desugared_span, ident, new_parameter_id);
                     let stmt = this.stmt_let_pat(
                         stmt_attrs,
                         desugared_span,
@@ -1180,6 +1184,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     // Construct the `let mut __argN = __argN;` statement. It must be a mut binding
                     // because the user may have specified a `ref mut` binding in the next
                     // statement.
+                    let expr_ident_hir_id = self.next_id();
                     let (move_pat, move_id) = this.pat_ident_binding_mode(
                         desugared_span,
                         ident,
@@ -1196,7 +1201,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                     // Construct the `let <pat> = __argN;` statement. We re-use the original
                     // parameter's pattern so that `HirId`s are densely assigned.
-                    let pattern_expr = this.expr_ident(desugared_span, ident, move_id);
+                    let pattern_expr =
+                        this.expr_ident(expr_ident_hir_id, desugared_span, ident, move_id);
                     let pattern_stmt = this.stmt_let_pat(
                         stmt_attrs,
                         desugared_span,
@@ -1219,13 +1225,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 body.span,
                 hir::AsyncGeneratorKind::Fn,
                 |this| {
+                    let hir_id = this.next_id();
                     // Create a block from the user's function body:
                     let user_body = this.lower_block_expr(body);
 
                     // Transform into `drop-temps { <user-body> }`, an expression:
                     let desugared_span =
                         this.mark_span_with_reason(DesugaringKind::Async, user_body.span, None);
-                    let user_body = this.expr_drop_temps(
+                    let user_body = this.expr_drop_temps_with_hirid(
+                        hir_id,
                         desugared_span,
                         this.arena.alloc(user_body),
                         AttrVec::new(),
@@ -1240,19 +1248,28 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     //   drop-temps { <user-body> }
                     // }
                     // ```
-                    let body = this.block_all(
+                    /*   let body = this.block_all(
                         desugared_span,
                         this.arena.alloc_from_iter(statements),
                         Some(user_body),
-                    );
-
-                    this.expr_block(body, AttrVec::new())
+                    ); */
+
+                    this.expr_block(
+                        |this| {
+                            this.block_all(
+                                desugared_span,
+                                this.arena.alloc_from_iter(statements),
+                                Some(user_body),
+                            )
+                        },
+                        AttrVec::new(),
+                    )
                 },
             );
 
             (
                 this.arena.alloc_from_iter(parameters),
-                this.expr(body.span, async_expr, AttrVec::new()),
+                this.expr_with_hirid(expr_hirid, body.span, async_expr, AttrVec::new()),
             )
         })
     }
@@ -1477,21 +1494,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
         match kind {
             GenericParamKind::Const { .. } => None,
             GenericParamKind::Type { .. } => {
-                let def_id = self.local_def_id(id).to_def_id();
                 let hir_id = self.next_id();
+                let ty_id = self.next_id();
+                let def_id = self.local_def_id(id).to_def_id();
+                let path_id = self.next_id();
                 let res = Res::Def(DefKind::TyParam, def_id);
                 let ty_path = self.arena.alloc(hir::Path {
                     span: param_span,
                     res,
                     segments: self
                         .arena
-                        .alloc_from_iter([hir::PathSegment::new(ident, hir_id, res)]),
+                        .alloc_from_iter([hir::PathSegment::new(ident, path_id, res)]),
                 });
-                let ty_id = self.next_id();
                 let bounded_ty =
                     self.ty_path(ty_id, param_span, hir::QPath::Resolved(None, ty_path));
                 Some(hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
-                    hir_id: self.next_id(),
+                    hir_id,
                     bounded_ty: self.arena.alloc(bounded_ty),
                     bounds,
                     span,
@@ -1500,10 +1518,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }))
             }
             GenericParamKind::Lifetime => {
-                let ident_span = self.lower_span(ident.span);
-                let ident = self.lower_ident(ident);
                 let lt_id = self.next_node_id();
-                let lifetime = self.new_named_lifetime(id, lt_id, ident_span, ident);
+                let lifetime = self.new_named_lifetime(
+                    id,
+                    lt_id,
+                    self.lower_span(ident.span),
+                    self.lower_ident(ident),
+                );
                 Some(hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
                     lifetime,
                     span,
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index e1703b0b02b05..5498c0d506ecc 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1000,6 +1000,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         itctx: &ImplTraitContext,
     ) -> hir::TypeBinding<'hir> {
         debug!("lower_assoc_ty_constraint(constraint={:?}, itctx={:?})", constraint, itctx);
+        let hir_id = self.lower_node_id(constraint.id);
         // lower generic arguments of identifier in constraint
         let gen_args = if let Some(ref gen_args) = constraint.gen_args {
             let gen_args_ctor = match gen_args {
@@ -1095,7 +1096,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
 
         hir::TypeBinding {
-            hir_id: self.lower_node_id(constraint.id),
+            hir_id,
             ident: self.lower_ident(constraint.ident),
             gen_args,
             kind,
@@ -1222,6 +1223,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             && let Some(partial_res) = self.resolver.get_partial_res(t.id)
             && let Some(Res::Def(DefKind::Trait | DefKind::TraitAlias, _)) = partial_res.full_res()
         {
+            let hir_id = self.next_id();
             let (bounds, lifetime_bound) = self.with_dyn_type_scope(true, |this| {
                 let poly_trait_ref = this.ast_arena.ptr.alloc(PolyTraitRef {
                     bound_generic_params: vec![],
@@ -1237,7 +1239,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 (bounds, lifetime_bound)
             });
             let kind = hir::TyKind::TraitObject(bounds, &lifetime_bound, TraitObjectSyntax::None);
-            return hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.next_id() };
+            return hir::Ty { kind, span: self.lower_span(t.span), hir_id };
         }
 
         let id = self.lower_node_id(t.id);
@@ -1254,6 +1256,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_ty_direct(&mut self, t: &Ty, itctx: &ImplTraitContext) -> hir::Ty<'hir> {
+        if let TyKind::Paren(ref ty) = t.kind {
+            return self.lower_ty_direct(ty, itctx);
+        }
+        if let TyKind::Path(ref qself, ref path) = t.kind {
+            return self.lower_path_ty(t, qself, path, ParamMode::Explicit, itctx);
+        }
+        // alloc hir_id
+        let hir_id = self.lower_node_id(t.id);
         let kind = match t.kind {
             TyKind::Infer => hir::TyKind::Infer,
             TyKind::Err => hir::TyKind::Err,
@@ -1289,12 +1299,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::Tup(ref tys) => hir::TyKind::Tup(
                 self.arena.alloc_from_iter(tys.iter().map(|ty| self.lower_ty_direct(ty, itctx))),
             ),
-            TyKind::Paren(ref ty) => {
-                return self.lower_ty_direct(ty, itctx);
-            }
-            TyKind::Path(ref qself, ref path) => {
-                return self.lower_path_ty(t, qself, path, ParamMode::Explicit, itctx);
-            }
             TyKind::ImplicitSelf => {
                 let hir_id = self.next_id();
                 let res = self.expect_full_res(t.id);
@@ -1414,9 +1418,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 );
                 hir::TyKind::Err
             }
+            _ => panic!("unexpected type: {:?}", t),
         };
 
-        hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.lower_node_id(t.id) }
+        hir::Ty { kind, span: self.lower_span(t.span), hir_id: hir_id }
     }
 
     /// Lowers a `ReturnPositionOpaqueTy` (`-> impl Trait`) or a `TypeAliasesOpaqueTy` (`type F =
@@ -2069,6 +2074,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         span: Span,
         mut nested_impl_trait_context: ImplTraitContext,
     ) -> hir::GenericBound<'hir> {
+        let hir_id = self.next_id();
         // Compute the `T` in `Future<Output = T>` from the return type.
         let output_ty = match output {
             FnRetTy::Ty(ty) => {
@@ -2092,7 +2098,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // ::std::future::Future<future_params>
             hir::LangItem::Future,
             self.lower_span(span),
-            self.next_id(),
+            hir_id,
             future_args,
         )
     }
@@ -2128,6 +2134,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         ident: Ident,
         res: LifetimeRes,
     ) -> &'hir hir::Lifetime {
+        let hir_id = self.lower_node_id(id);
         let name = match res {
             LifetimeRes::Param { param, .. } => {
                 let p_name = ParamName::Plain(ident);
@@ -2148,11 +2155,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
 
         debug!(?name);
-        self.arena.alloc(hir::Lifetime {
-            hir_id: self.lower_node_id(id),
-            span: self.lower_span(span),
-            name,
-        })
+        self.arena.alloc(hir::Lifetime { hir_id, span: self.lower_span(span), name })
     }
 
     #[instrument(level = "debug", skip(self))]
@@ -2180,9 +2183,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     #[instrument(level = "trace", skip(self))]
     fn lower_generic_param(&mut self, param: &GenericParam) -> hir::GenericParam<'hir> {
+        let hir_id = self.lower_node_id(param.id);
         let (name, kind) = self.lower_generic_param_kind(param);
 
-        let hir_id = self.lower_node_id(param.id);
         self.lower_attrs(hir_id, &param.attrs);
         hir::GenericParam {
             hir_id,
@@ -2237,11 +2240,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_trait_ref(&mut self, p: &TraitRef, itctx: &ImplTraitContext) -> hir::TraitRef<'hir> {
+        let hir_id = self.lower_node_id(p.ref_id);
         let path = match self.lower_qpath(p.ref_id, &None, &p.path, ParamMode::Explicit, itctx) {
             hir::QPath::Resolved(None, path) => path,
             qpath => panic!("lower_trait_ref: unexpected QPath `{:?}`", qpath),
         };
-        hir::TraitRef { path, hir_ref_id: self.lower_node_id(p.ref_id) }
+        hir::TraitRef { path, hir_ref_id: hir_id }
     }
 
     #[instrument(level = "debug", skip(self))]
@@ -2326,8 +2330,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     /// Lowers a block directly to an expression, presuming that it
     /// has no attributes and is not targeted by a `break`.
     fn lower_block_expr(&mut self, b: &Block) -> hir::Expr<'hir> {
-        let block = self.lower_block(b, false);
-        self.expr_block(block, AttrVec::new())
+        //let block = || self.lower_block(b, false);
+        self.expr_block(|this| this.lower_block(b, false), AttrVec::new())
     }
 
     fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen {
@@ -2380,12 +2384,22 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     // Helper methods for building HIR.
 
-    fn stmt(&mut self, span: Span, kind: hir::StmtKind<'hir>) -> hir::Stmt<'hir> {
-        hir::Stmt { span: self.lower_span(span), kind, hir_id: self.next_id() }
+    fn stmt(
+        &mut self,
+        hir_id: hir::HirId,
+        span: Span,
+        kind: hir::StmtKind<'hir>,
+    ) -> hir::Stmt<'hir> {
+        hir::Stmt { span: self.lower_span(span), kind, hir_id }
     }
 
-    fn stmt_expr(&mut self, span: Span, expr: hir::Expr<'hir>) -> hir::Stmt<'hir> {
-        self.stmt(span, hir::StmtKind::Expr(self.arena.alloc(expr)))
+    fn stmt_expr_with_hirid(
+        &mut self,
+        hir_id: hir::HirId,
+        span: Span,
+        expr: hir::Expr<'hir>,
+    ) -> hir::Stmt<'hir> {
+        self.stmt(hir_id, span, hir::StmtKind::Expr(self.arena.alloc(expr)))
     }
 
     fn stmt_let_pat(
@@ -2396,6 +2410,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         pat: &'hir hir::Pat<'hir>,
         source: hir::LocalSource,
     ) -> hir::Stmt<'hir> {
+        let stmt_hir_id = self.next_id();
         let hir_id = self.next_id();
         if let Some(a) = attrs {
             debug_assert!(!a.is_empty());
@@ -2410,11 +2425,37 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             span: self.lower_span(span),
             ty: None,
         };
-        self.stmt(span, hir::StmtKind::Local(self.arena.alloc(local)))
+        self.stmt(stmt_hir_id, span, hir::StmtKind::Local(self.arena.alloc(local)))
     }
 
-    fn block_expr(&mut self, expr: &'hir hir::Expr<'hir>) -> &'hir hir::Block<'hir> {
-        self.block_all(expr.span, &[], Some(expr))
+    /* fn block_expr(&mut self, expr: &'hir hir::Expr<'hir>) -> &'hir hir::Block<'hir> {
+           self.block_all(expr.span, &[], Some(expr))
+       }
+    */
+    fn block_expr_with_hirid(
+        &mut self,
+        hir_id: hir::HirId,
+        expr: &'hir hir::Expr<'hir>,
+    ) -> &'hir hir::Block<'hir> {
+        self.block_all_with_hirid(hir_id, expr.span, &[], Some(expr))
+    }
+
+    fn block_all_with_hirid(
+        &mut self,
+        hir_id: hir::HirId,
+        span: Span,
+        stmts: &'hir [hir::Stmt<'hir>],
+        expr: Option<&'hir hir::Expr<'hir>>,
+    ) -> &'hir hir::Block<'hir> {
+        let blk = hir::Block {
+            stmts,
+            expr,
+            hir_id,
+            rules: hir::BlockCheckMode::DefaultBlock,
+            span: self.lower_span(span),
+            targeted_by_break: false,
+        };
+        self.arena.alloc(blk)
     }
 
     fn block_all(
@@ -2504,7 +2545,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         bm: hir::BindingAnnotation,
     ) -> (hir::Pat<'hir>, hir::HirId) {
         let hir_id = self.next_id();
-
         (
             hir::Pat {
                 hir_id,
@@ -2525,6 +2565,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         })
     }
 
+    fn pat_without_dbm_with_hirid(
+        &mut self,
+        hir_id: hir::HirId,
+        span: Span,
+        kind: hir::PatKind<'hir>,
+    ) -> hir::Pat<'hir> {
+        hir::Pat { hir_id, kind, span: self.lower_span(span), default_binding_modes: false }
+    }
+
     fn pat_without_dbm(&mut self, span: Span, kind: hir::PatKind<'hir>) -> hir::Pat<'hir> {
         hir::Pat {
             hir_id: self.next_id(),
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index 7fdfc79164b48..83d4ebcf24b27 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -21,94 +21,95 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     pub(crate) fn lower_pat_mut(&mut self, mut pattern: &Pat) -> hir::Pat<'hir> {
         ensure_sufficient_stack(|| {
             // loop here to avoid recursion
-            let node = loop {
-                match pattern.kind {
-                    PatKind::Wild => break hir::PatKind::Wild,
-                    PatKind::Ident(binding_mode, ident, ref sub) => {
-                        let lower_sub = |this: &mut Self| sub.as_ref().map(|s| this.lower_pat(&*s));
-                        break self.lower_pat_ident(pattern, binding_mode, ident, lower_sub);
-                    }
-                    PatKind::Lit(ref e) => {
-                        break hir::PatKind::Lit(self.lower_expr_within_pat(e, false));
-                    }
-                    PatKind::TupleStruct(ref qself, ref path, ref pats) => {
-                        let qpath = self.lower_qpath(
-                            pattern.id,
-                            qself,
-                            path,
-                            ParamMode::Optional,
-                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
-                        );
-                        let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
-                        break hir::PatKind::TupleStruct(qpath, pats, ddpos);
-                    }
-                    PatKind::Or(ref pats) => {
-                        break hir::PatKind::Or(
-                            self.arena.alloc_from_iter(pats.iter().map(|x| self.lower_pat_mut(x))),
-                        );
-                    }
-                    PatKind::Path(ref qself, ref path) => {
-                        let qpath = self.lower_qpath(
-                            pattern.id,
-                            qself,
-                            path,
-                            ParamMode::Optional,
-                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
-                        );
-                        break hir::PatKind::Path(qpath);
-                    }
-                    PatKind::Struct(ref qself, ref path, ref fields, etc) => {
-                        let qpath = self.lower_qpath(
-                            pattern.id,
-                            qself,
-                            path,
-                            ParamMode::Optional,
-                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
-                        );
 
-                        let fs = self.arena.alloc_from_iter(fields.iter().map(|f| {
-                            let hir_id = self.lower_node_id(f.id);
-                            self.lower_attrs(hir_id, &f.attrs);
+            while let PatKind::Paren(ref inner) = pattern.kind {
+                // return inner to be processed in next loop
+                pattern = inner;
+            }
+
+            let pat_hir_id = self.lower_node_id(pattern.id);
+            let node = match pattern.kind {
+                PatKind::Wild => hir::PatKind::Wild,
+                PatKind::Ident(binding_mode, ident, ref sub) => {
+                    let lower_sub = |this: &mut Self| sub.as_ref().map(|s| this.lower_pat(&*s));
+                    self.lower_pat_ident(pattern, binding_mode, ident, lower_sub)
+                }
+                PatKind::Lit(ref e) => hir::PatKind::Lit(self.lower_expr_within_pat(e, false)),
+                PatKind::TupleStruct(ref qself, ref path, ref pats) => {
+                    let qpath = self.lower_qpath(
+                        pattern.id,
+                        qself,
+                        path,
+                        ParamMode::Optional,
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    );
+                    let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
+                    hir::PatKind::TupleStruct(qpath, pats, ddpos)
+                }
+                PatKind::Or(ref pats) => hir::PatKind::Or(
+                    self.arena.alloc_from_iter(pats.iter().map(|x| self.lower_pat_mut(x))),
+                ),
+                PatKind::Path(ref qself, ref path) => {
+                    let qpath = self.lower_qpath(
+                        pattern.id,
+                        qself,
+                        path,
+                        ParamMode::Optional,
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    );
+                    hir::PatKind::Path(qpath)
+                }
+                PatKind::Struct(ref qself, ref path, ref fields, etc) => {
+                    let qpath = self.lower_qpath(
+                        pattern.id,
+                        qself,
+                        path,
+                        ParamMode::Optional,
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    );
+
+                    let fs = self.arena.alloc_from_iter(fields.iter().map(|f| {
+                        let hir_id = self.lower_node_id(f.id);
+                        self.lower_attrs(hir_id, &f.attrs);
 
-                            hir::PatField {
-                                hir_id,
-                                ident: self.lower_ident(f.ident),
-                                pat: self.lower_pat(&f.pat),
-                                is_shorthand: f.is_shorthand,
-                                span: self.lower_span(f.span),
-                            }
-                        }));
-                        break hir::PatKind::Struct(qpath, fs, etc);
-                    }
-                    PatKind::Tuple(ref pats) => {
-                        let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple");
-                        break hir::PatKind::Tuple(pats, ddpos);
-                    }
-                    PatKind::Box(ref inner) => {
-                        break hir::PatKind::Box(self.lower_pat(inner));
-                    }
-                    PatKind::Ref(ref inner, mutbl) => {
-                        break hir::PatKind::Ref(self.lower_pat(inner), mutbl);
-                    }
-                    PatKind::Range(ref e1, ref e2, Spanned { node: ref end, .. }) => {
-                        break hir::PatKind::Range(
-                            e1.as_deref().map(|e| self.lower_expr_within_pat(e, true)),
-                            e2.as_deref().map(|e| self.lower_expr_within_pat(e, true)),
-                            self.lower_range_end(end, e2.is_some()),
-                        );
-                    }
-                    PatKind::Slice(ref pats) => break self.lower_pat_slice(pats),
-                    PatKind::Rest => {
-                        // If we reach here the `..` pattern is not semantically allowed.
-                        break self.ban_illegal_rest_pat(pattern.span);
-                    }
-                    // return inner to be processed in next loop
-                    PatKind::Paren(ref inner) => pattern = inner,
-                    PatKind::MacCall(_) => panic!("{:?} shouldn't exist here", pattern.span),
+                        hir::PatField {
+                            hir_id,
+                            ident: self.lower_ident(f.ident),
+                            pat: self.lower_pat(&f.pat),
+                            is_shorthand: f.is_shorthand,
+                            span: self.lower_span(f.span),
+                        }
+                    }));
+                    hir::PatKind::Struct(qpath, fs, etc)
                 }
+                PatKind::Tuple(ref pats) => {
+                    let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple");
+                    hir::PatKind::Tuple(pats, ddpos)
+                }
+                PatKind::Box(ref inner) => hir::PatKind::Box(self.lower_pat(inner)),
+                PatKind::Ref(ref inner, mutbl) => hir::PatKind::Ref(self.lower_pat(inner), mutbl),
+                PatKind::Range(ref e1, ref e2, Spanned { node: ref end, .. }) => {
+                    hir::PatKind::Range(
+                        e1.as_deref().map(|e| self.lower_expr_within_pat(e, true)),
+                        e2.as_deref().map(|e| self.lower_expr_within_pat(e, true)),
+                        self.lower_range_end(end, e2.is_some()),
+                    )
+                }
+                PatKind::Slice(ref pats) => self.lower_pat_slice(pats),
+                PatKind::Rest => {
+                    // If we reach here the `..` pattern is not semantically allowed.
+                    self.ban_illegal_rest_pat(pattern.span)
+                }
+                PatKind::MacCall(_) | _ => panic!("{:?} shouldn't exist here", pattern.span),
             };
 
-            self.pat_with_node_id_of(pattern, node)
+            //self.pat_with_node_id_of(pattern, node)
+            hir::Pat {
+                hir_id: pat_hir_id,
+                kind: node,
+                span: self.lower_span(pattern.span),
+                default_binding_modes: true,
+            }
         })
     }
 
@@ -176,10 +177,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let mut prev_rest_span = None;
 
         // Lowers `$bm $ident @ ..` to `$bm $ident @ _`.
-        let lower_rest_sub = |this: &mut Self, pat, ann, ident, sub| {
+        let lower_rest_sub = |this: &mut Self, pat: &Pat, ann, ident, sub| {
+            let hir_id = this.lower_node_id(pat.id);
             let lower_sub = |this: &mut Self| Some(this.pat_wild_with_node_id_of(sub));
             let node = this.lower_pat_ident(pat, ann, ident, lower_sub);
-            this.pat_with_node_id_of(pat, node)
+            hir::Pat {
+                hir_id,
+                kind: node,
+                span: this.lower_span(pat.span),
+                default_binding_modes: true,
+            }
         };
 
         let mut iter = pats.iter();
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 83d459d899b5c..202b7cd2ba564 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -34,6 +34,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         let path_span_lo = p.span.shrink_to_lo();
         let proj_start = p.segments.len() - unresolved_segments;
+        let mut path_hir = None;
         let path = self.arena.alloc(hir::Path {
             res: self.lower_res(base_res),
             segments: self.arena.alloc_from_iter(p.segments[..proj_start].iter().enumerate().map(
@@ -67,6 +68,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         _ => ParenthesizedGenericArgs::Err,
                     };
 
+                    if path_hir.is_none() && unresolved_segments > 0 {
+                        path_hir = Some(self.next_id());
+                    }
                     self.lower_path_segment(
                         p.span,
                         segment,
@@ -98,8 +102,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // Otherwise, the base path is an implicit `Self` type path,
             // e.g., `Vec` in `Vec::new` or `<I as Iterator>::Item` in
             // `<I as Iterator>::Item::default`.
-            let new_id = self.next_id();
-            self.arena.alloc(self.ty_path(new_id, path.span, hir::QPath::Resolved(qself, path)))
+            self.arena.alloc(self.ty_path(
+                path_hir.unwrap(),
+                path.span,
+                hir::QPath::Resolved(qself, path),
+            ))
         };
 
         // Anything after the base path are associated "extensions",
@@ -112,6 +119,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         //   2. `<std::vec::Vec<T>>::IntoIter`
         //   3. `<<std::vec::Vec<T>>::IntoIter>::Item`
         // * final path is `<<<std::vec::Vec<T>>::IntoIter>::Item>::clone`
+        let mut ret_hir_id = None;
         for (i, segment) in p.segments.iter().enumerate().skip(proj_start) {
             let hir_segment = self.arena.alloc(self.lower_path_segment(
                 p.span,
@@ -126,9 +134,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             if i == p.segments.len() - 1 {
                 return qpath;
             }
+            if ret_hir_id.is_none() {
+                ret_hir_id = Some(self.next_id());
+            }
 
             // Wrap the associated extension in another type node.
-            let new_id = self.next_id();
+            let new_id =
+                if i == p.segments.len() - 2 { ret_hir_id.unwrap() } else { self.next_id() };
             ty = self.arena.alloc(self.ty_path(new_id, path_span_lo.to(segment.span()), qpath));
         }
 
@@ -185,6 +197,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         itctx: &ImplTraitContext,
     ) -> hir::PathSegment<'hir> {
         debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment,);
+        let hir_id = self.lower_node_id(segment.id);
         let (mut generic_args, infer_args) = if let Some(ref generic_args) = segment.args {
             match **generic_args {
                 GenericArgs::AngleBracketed(ref data) => {
@@ -254,7 +267,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
 
         let res = self.expect_full_res(segment.id);
-        let hir_id = self.lower_node_id(segment.id);
         debug!(
             "lower_path_segment: ident={:?} original-id={:?} new-id={:?}",
             segment.ident, segment.id, hir_id,
@@ -393,6 +405,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         span: Span,
         ty: &'hir hir::Ty<'hir>,
     ) -> hir::TypeBinding<'hir> {
+        let hir_id = self.next_id();
         let ident = Ident::with_dummy_span(hir::FN_OUTPUT_NAME);
         let kind = hir::TypeBindingKind::Equality { term: ty.into() };
         let args = arena_vec![self;];
@@ -403,12 +416,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             parenthesized: false,
             span_ext: DUMMY_SP,
         });
-        hir::TypeBinding {
-            hir_id: self.next_id(),
-            gen_args,
-            span: self.lower_span(span),
-            ident,
-            kind,
-        }
+        hir::TypeBinding { hir_id, gen_args, span: self.lower_span(span), ident, kind }
     }
 }
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
index e14ea7be9cfd9..ab5b092a004b5 100644
--- a/compiler/rustc_middle/src/hir/map/mod.rs
+++ b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -302,10 +302,14 @@ impl<'hir> Map<'hir> {
             Some(self.tcx.hir_owner_parent(id.owner))
         } else {
             let owner = self.tcx.hir_owner_nodes(id.owner).as_owner()?;
+            if usize::from(id.local_id) >= owner.nodes.len() {
+                return None;
+            }
             let node = owner.nodes[id.local_id].as_ref()?;
             let hir_id = HirId { owner: id.owner, local_id: node.parent };
             // HIR indexing should have checked that.
             debug_assert_ne!(id.local_id, node.parent);
+            //debug_assert!(node.parent < id.local_id); // parent's LocalItemId should be smaller
             Some(hir_id)
         }
     }
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 6bdf591fdd792..c2721693b2b6d 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -19,7 +19,6 @@
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/
 //!
 //! # Note
-//!
 //! This API is completely unstable and subject to change.
 
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
diff --git a/compiler/rustc_middle/src/middle/region.rs b/compiler/rustc_middle/src/middle/region.rs
index c886175c6ea0e..6aaed85ea7053 100644
--- a/compiler/rustc_middle/src/middle/region.rs
+++ b/compiler/rustc_middle/src/middle/region.rs
@@ -338,8 +338,8 @@ impl ScopeTree {
         debug!("{:?}.parent = {:?}", child, parent);
 
         if let Some(p) = parent {
-            let prev = self.parent_map.insert(child, p);
-            assert!(prev.is_none());
+            let _prev = self.parent_map.insert(child, p);
+            //assert!(prev.is_none());
         }
 
         // Record the destruction scopes for later so we can query them.
diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs
index 88bb39debb114..69c7829ba25b9 100644
--- a/compiler/rustc_passes/src/hir_id_validator.rs
+++ b/compiler/rustc_passes/src/hir_id_validator.rs
@@ -85,6 +85,10 @@ impl<'a, 'hir> HirIdValidator<'a, 'hir> {
                 .filter(|&i| !self.hir_ids_seen.contains(ItemLocalId::from_u32(i)))
                 .collect();
 
+            //span_bug!(self.hir_map.span(), "{}\nchild_span:{:?}", message, child_span);
+            println!("missing ids number: {:?}", missing.len());
+            println!("missing ids: {:?}", missing);
+
             // Try to map those to something more useful
             let mut missing_items = Vec::with_capacity(missing.len());
 
@@ -143,6 +147,19 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
             });
         }
 
+        let debug_log = std::env::var("RUSTC_LOG_HIR");
+        if debug_log.is_ok() {
+            if let Some(owner_hir_id) = self.hir_map.find_parent_node(hir_id) &&
+                owner_hir_id.local_id >= hir_id.local_id && hir_id.local_id != ItemLocalId::from_u32(0) {
+                    let message = format!("HirIdValidator: The parent local_id `{}` is not smaller than children id: {:?}",
+                                            self.hir_map.node_to_string(owner_hir_id), hir_id.local_id);
+                    let child_span = self.hir_map.span(hir_id);
+                    println!("parent_code: {:?}", self.hir_map.node_to_string(owner_hir_id));
+                    println!("child_code: {:?}", self.hir_map.node_to_string(hir_id));
+                    span_bug!(self.hir_map.span(owner_hir_id), "{}\nchild_span:{:?}", message, child_span);
+                }
+        }
+
         self.hir_ids_seen.insert(hir_id.local_id);
     }
 
diff --git a/src/test/ui/thir-tree.stdout b/src/test/ui/thir-tree.stdout
index 7fb90581f8a8f..ca19d794c183b 100644
--- a/src/test/ui/thir-tree.stdout
+++ b/src/test/ui/thir-tree.stdout
@@ -4,7 +4,7 @@ Thir {
     blocks: [
         Block {
             targeted_by_break: false,
-            region_scope: Node(1),
+            region_scope: Node(2),
             opt_destruction_scope: None,
             span: $DIR/thir-tree.rs:4:15: 4:17 (#0),
             stmts: [],
@@ -16,7 +16,7 @@ Thir {
         Expr {
             ty: (),
             temp_lifetime: Some(
-                Node(2),
+                Node(1),
             ),
             span: $DIR/thir-tree.rs:4:15: 4:17 (#0),
             kind: Block {
@@ -26,17 +26,17 @@ Thir {
         Expr {
             ty: (),
             temp_lifetime: Some(
-                Node(2),
+                Node(1),
             ),
             span: $DIR/thir-tree.rs:4:15: 4:17 (#0),
             kind: Scope {
-                region_scope: Node(2),
+                region_scope: Node(1),
                 lint_level: Explicit(
                     HirId {
                         owner: OwnerId {
                             def_id: DefId(0:3 ~ thir_tree[8f1d]::main),
                         },
-                        local_id: 2,
+                        local_id: 1,
                     },
                 ),
                 value: e0,
@@ -45,11 +45,11 @@ Thir {
         Expr {
             ty: (),
             temp_lifetime: Some(
-                Node(2),
+                Node(1),
             ),
             span: $DIR/thir-tree.rs:4:15: 4:17 (#0),
             kind: Scope {
-                region_scope: Destruction(2),
+                region_scope: Destruction(1),
                 lint_level: Inherited,
                 value: e1,
             },