Work on removing HirId from hir::Stmt

Author: Aaron1011

compiler/rustc_ast_lowering/src/lib.rs

@@ -2415,49 +2415,41 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_stmt(&mut self, s: &Stmt) -> SmallVec<[hir::Stmt<'hir>; 1]> {
-        let (hir_id, kind) = match s.kind {
+        let kind = match s.kind {
             StmtKind::Local(ref l) => {
                 let l = self.lower_local(l);
                 let hir_id = self.lower_node_id(s.id());
                 self.alias_attrs(hir_id, l.hir_id);
                 return smallvec![hir::Stmt {
-                    hir_id,
                     kind: hir::StmtKind::Local(self.arena.alloc(l)),
                     span: s.span,
                 }];
             }
             StmtKind::Item(ref it) => {
-                // Can only use the ID once.
-                let mut id = Some(s.id());
                 return self
                     .lower_item_id(it)
                     .into_iter()
                     .map(|item_id| {
-                        let hir_id = id
-                            .take()
-                            .map(|id| self.lower_node_id(id))
-                            .unwrap_or_else(|| self.next_id());
-
-                        hir::Stmt { hir_id, kind: hir::StmtKind::Item(item_id), span: s.span }
+                        hir::Stmt { kind: hir::StmtKind::Item(item_id), span: s.span }
                     })
                     .collect();
             }
             StmtKind::Expr(ref e) => {
                 let e = self.lower_expr(e);
                 let hir_id = self.lower_node_id(s.id());
                 self.alias_attrs(hir_id, e.hir_id);
-                (hir_id, hir::StmtKind::Expr(e))
+                hir::StmtKind::Expr(e)
             }
             StmtKind::Semi(ref e) => {
                 let e = self.lower_expr(e);
                 let hir_id = self.lower_node_id(s.id());
                 self.alias_attrs(hir_id, e.hir_id);
-                (hir_id, hir::StmtKind::Semi(e))
+                hir::StmtKind::Semi(e)
             }
             StmtKind::Empty { id: _ } => return smallvec![],
             StmtKind::MacCall(..) => panic!("shouldn't exist here"),
         };
-        smallvec![hir::Stmt { hir_id, kind, span: s.span }]
+        smallvec![hir::Stmt { kind, span: s.span }]
     }
 
     fn lower_block_check_mode(&mut self, b: &BlockCheckMode) -> hir::BlockCheckMode {
@@ -2492,7 +2484,7 @@ 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, kind, hir_id: self.next_id() }
+        hir::Stmt { span, kind }
     }
 
     fn stmt_expr(&mut self, span: Span, expr: hir::Expr<'hir>) -> hir::Stmt<'hir> {

compiler/rustc_hir/src/hir.rs

@@ -1162,7 +1162,6 @@ impl UnOp {
 /// A statement.
 #[derive(Debug, HashStable_Generic)]
 pub struct Stmt<'hir> {
-    pub hir_id: HirId,
     pub kind: StmtKind<'hir>,
     pub span: Span,
 }
@@ -1183,6 +1182,16 @@ pub enum StmtKind<'hir> {
     Semi(&'hir Expr<'hir>),
 }
 
+impl<'hir> StmtKind<'hir> {
+    pub fn hir_id(&self) -> HirId {
+        match self {
+            StmtKind::Local(local) => local.hir_id,
+            StmtKind::Item(id) => id.hir_id(),
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.hir_id,
+        }
+    }
+}
+
 /// Represents a `let` statement (i.e., `let <pat>:<ty> = <expr>;`).
 #[derive(Debug, HashStable_Generic)]
 pub struct Local<'hir> {
@@ -3233,7 +3242,6 @@ impl<'hir> Node<'hir> {
             Node::Field(FieldDef { hir_id, .. })
             | Node::AnonConst(AnonConst { hir_id, .. })
             | Node::Expr(Expr { hir_id, .. })
-            | Node::Stmt(Stmt { hir_id, .. })
             | Node::Ty(Ty { hir_id, .. })
             | Node::Binding(Pat { hir_id, .. })
             | Node::Pat(Pat { hir_id, .. })
@@ -3244,6 +3252,7 @@ impl<'hir> Node<'hir> {
             | Node::Param(Param { hir_id, .. })
             | Node::Infer(InferArg { hir_id, .. })
             | Node::GenericParam(GenericParam { hir_id, .. }) => Some(*hir_id),
+            Node::Stmt(stmt) => Some(stmt.kind.hir_id()),
             Node::TraitRef(TraitRef { hir_ref_id, .. }) => Some(*hir_ref_id),
             Node::PathSegment(PathSegment { hir_id, .. }) => *hir_id,
             Node::Variant(Variant { id, .. }) => Some(*id),

compiler/rustc_hir/src/intravisit.rs

@@ -1102,7 +1102,6 @@ pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block<'v>) {
 }
 
 pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt<'v>) {
-    visitor.visit_id(statement.hir_id);
     match statement.kind {
         StmtKind::Local(ref local) => visitor.visit_local(local),
         StmtKind::Item(item) => visitor.visit_nested_item(item),

compiler/rustc_lint/src/late.rs

@@ -180,7 +180,7 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
     fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) {
         // See `EarlyContextAndPass::visit_stmt` for an explanation
         // of why we call `walk_stmt` outside of `with_lint_attrs`
-        self.with_lint_attrs(s.hir_id, |cx| {
+        self.with_lint_attrs(s.kind.hir_id(), |cx| {
             lint_callback!(cx, check_stmt, s);
         });
         hir_visit::walk_stmt(self, s);

compiler/rustc_middle/src/hir/map/collector.rs

@@ -313,14 +313,6 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         });
     }
 
-    fn visit_stmt(&mut self, stmt: &'hir Stmt<'hir>) {
-        self.insert(stmt.span, stmt.hir_id, Node::Stmt(stmt));
-
-        self.with_parent(stmt.hir_id, |this| {
-            intravisit::walk_stmt(this, stmt);
-        });
-    }
-
     fn visit_path_segment(&mut self, path_span: Span, path_segment: &'hir PathSegment<'hir>) {
         if let Some(hir_id) = path_segment.hir_id {
             self.insert(path_span, hir_id, Node::PathSegment(path_segment));

compiler/rustc_mir_build/src/thir/cx/block.rs

@@ -45,7 +45,7 @@ impl<'tcx> Cx<'tcx> {
             .iter()
             .enumerate()
             .filter_map(|(index, stmt)| {
-                let hir_id = stmt.hir_id;
+                let hir_id = stmt.kind.hir_id();
                 let opt_dxn_ext = self.region_scope_tree.opt_destruction_scope(hir_id.local_id);
                 match stmt.kind {
                     hir::StmtKind::Expr(ref expr) | hir::StmtKind::Semi(ref expr) => {

compiler/rustc_passes/src/hir_stats.rs

@@ -145,7 +145,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
     }
 
     fn visit_stmt(&mut self, s: &'v hir::Stmt<'v>) {
-        self.record("Stmt", Id::Node(s.hir_id), s);
+        self.record("Stmt", Id::Node(s.kind.hir_id()), s);
         hir_visit::walk_stmt(self, s)
     }
 

compiler/rustc_passes/src/region.rs

@@ -185,7 +185,7 @@ fn resolve_pat<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, pat: &'tcx hir
 }
 
 fn resolve_stmt<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, stmt: &'tcx hir::Stmt<'tcx>) {
-    let stmt_id = stmt.hir_id.local_id;
+    let stmt_id = stmt.kind.hir_id().local_id;
     debug!("resolve_stmt(stmt.id={:?})", stmt_id);
 
     // Every statement will clean up the temporaries created during

compiler/rustc_typeck/src/check/fn_ctxt/checks.rs

@@ -567,7 +567,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
         }
 
-        self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
+        self.warn_if_unreachable(stmt.kind.hir_id(), stmt.span, "statement");
 
         // Hide the outer diverging and `has_errors` flags.
         let old_diverges = self.diverges.replace(Diverges::Maybe);