Revert "Remove indirection for Expr in Body"

compiler/rustc_ast_lowering/src/item.rs

@@ -1216,7 +1216,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         params: &'hir [hir::Param<'hir>],
         value: hir::Expr<'hir>,
     ) -> hir::BodyId {
-        let body = hir::Body { params, value };
+        let body = hir::Body { params, value: self.arena.alloc(value) };
         let id = body.id();
         assert_eq!(id.hir_id.owner, self.curr_owner.owner_id());
         self.curr_owner.bodies.push((id.hir_id.local_id, self.arena.alloc(body)));

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -408,7 +408,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         }
         let tcx = self.infcx.tcx;
         if let Some(body) = tcx.hir_maybe_body_owned_by(self.mir_def_id()) {
-            let expr = &body.value;
+            let expr = body.value;
             let place = &self.move_data.move_paths[mpi].place;
             let span = place.as_local().map(|local| self.body.local_decls[local].source_info.span);
             let mut finder = ExpressionFinder {
@@ -2134,7 +2134,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
 
         let mut expr_finder = FindUselessClone::new(tcx, self.mir_def_id());
 
-        let body = &tcx.hir_body(body_id).value;
+        let body = tcx.hir_body(body_id).value;
         expr_finder.visit_expr(body);
 
         struct Holds<'tcx> {
@@ -2323,7 +2323,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         let tcx = self.infcx.tcx;
         let body_id = tcx.hir_node(self.mir_hir_id()).body_id()?;
         let mut expr_finder = FindExprBySpan::new(span, tcx);
-        expr_finder.visit_expr(&tcx.hir_body(body_id).value);
+        expr_finder.visit_expr(tcx.hir_body(body_id).value);
         expr_finder.result
     }
 
@@ -2554,7 +2554,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
             }
         }
         let mut finder = ExprFinder { tcx, expr_span: span, issue_span, .. };
-        finder.visit_expr(&tcx.hir_body(body_id).value);
+        finder.visit_expr(tcx.hir_body(body_id).value);
 
         if let Some(body_expr) = finder.body_expr
             && let Some(loop_span) = finder.loop_span
@@ -2705,7 +2705,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         // Get the body the error happens in
         let Some(body_id) = tcx.hir_node(self.mir_hir_id()).body_id() else { return };
 
-        let body_expr = &tcx.hir_body(body_id).value;
+        let body_expr = tcx.hir_body(body_id).value;
 
         struct ClosureFinder<'hir> {
             tcx: TyCtxt<'hir>,
@@ -2809,7 +2809,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
             }
 
             let mut finder = VariableUseFinder { local_id, spans: Vec::new() };
-            finder.visit_expr(&tcx.hir_body(closure.body).value);
+            finder.visit_expr(tcx.hir_body(closure.body).value);
 
             spans = finder.spans;
         } else {
@@ -4747,7 +4747,7 @@ fn find_for_loop_span<'hir>(
         }
     }
     let mut finder = ExprFinder { tcx, issue_span, result: None };
-    finder.visit_expr(&tcx.hir_body(body_id).value);
+    finder.visit_expr(tcx.hir_body(body_id).value);
     finder.result
 }
 

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -73,7 +73,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
             {
                 let body = tcx.hir_body(body_id);
                 let mut expr_finder = FindExprBySpan::new(span, tcx);
-                expr_finder.visit_expr(&body.value);
+                expr_finder.visit_expr(body.value);
                 if let Some(mut expr) = expr_finder.result {
                     while let hir::ExprKind::AddrOf(_, _, inner)
                     | hir::ExprKind::Unary(hir::UnOp::Deref, inner)
@@ -308,7 +308,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
                             && let hir_body = tcx.hir_body(body_id)
                             && let mut expr_finder = (FindLetExpr { span: old, result: None, tcx })
                             && let Some((let_expr_span, let_expr_pat, let_expr_init)) = {
-                                expr_finder.visit_expr(&hir_body.value);
+                                expr_finder.visit_expr(hir_body.value);
                                 expr_finder.result
                             }
                             && !let_expr_span.contains(new)

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -339,7 +339,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         // Find the closure that captured the binding.
         let mut expr_finder = FindExprBySpan::new(args_span, tcx);
         expr_finder.include_closures = true;
-        expr_finder.visit_expr(&tcx.hir_body(body_id).value);
+        expr_finder.visit_expr(tcx.hir_body(body_id).value);
         let Some(closure_expr) = expr_finder.result else { return };
         let ExprKind::Closure(closure) = closure_expr.kind else { return };
         // We'll only suggest cloning the binding if it's a `move` closure.
@@ -349,7 +349,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         let use_span = use_spans.var_or_use();
         let mut expr_finder = FindExprBySpan::new(use_span, tcx);
         expr_finder.include_closures = true;
-        expr_finder.visit_expr(&tcx.hir_body(body_id).value);
+        expr_finder.visit_expr(tcx.hir_body(body_id).value);
         let Some(use_expr) = expr_finder.result else { return };
         let parent = tcx.parent_hir_node(use_expr.hir_id);
         if let Node::Expr(expr) = parent

compiler/rustc_hir/src/hir.rs

@@ -1960,7 +1960,7 @@ pub struct BodyId {
 #[derive(Debug, Clone, Copy, StableHash)]
 pub struct Body<'hir> {
     pub params: &'hir [Param<'hir>],
-    pub value: Expr<'hir>,
+    pub value: &'hir Expr<'hir>,
 }
 
 impl<'hir> Body<'hir> {
@@ -5279,7 +5279,7 @@ mod size_asserts {
     use super::*;
     // tidy-alphabetical-start
     static_assert_size!(Block<'_>, 48);
-    static_assert_size!(Body<'_>, 80);
+    static_assert_size!(Body<'_>, 24);
     static_assert_size!(Expr<'_>, 64);
     static_assert_size!(ExprKind<'_>, 48);
     static_assert_size!(FnDecl<'_>, 40);

compiler/rustc_hir/src/intravisit.rs

@@ -296,7 +296,7 @@ pub trait Visitor<'v>: Sized {
         walk_item(self, i)
     }
 
-    fn visit_body(&mut self, b: &'v Body<'v>) -> Self::Result {
+    fn visit_body(&mut self, b: &Body<'v>) -> Self::Result {
         walk_body(self, b)
     }
 
@@ -662,10 +662,10 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
     V::Result::output()
 }
 
-pub fn walk_body<'v, V: Visitor<'v>>(visitor: &mut V, body: &'v Body<'v>) -> V::Result {
+pub fn walk_body<'v, V: Visitor<'v>>(visitor: &mut V, body: &Body<'v>) -> V::Result {
     let Body { params, value } = body;
     walk_list!(visitor, visit_param, *params);
-    visitor.visit_expr(value)
+    visitor.visit_expr(*value)
 }
 
 pub fn walk_ident<'v, V: Visitor<'v>>(visitor: &mut V, ident: Ident) -> V::Result {

compiler/rustc_hir_analysis/src/check/region.rs

@@ -762,7 +762,7 @@ impl<'tcx> Visitor<'tcx> for ScopeResolutionVisitor<'tcx> {
         resolve_block(self, b, false);
     }
 
-    fn visit_body(&mut self, body: &'tcx hir::Body<'tcx>) {
+    fn visit_body(&mut self, body: &hir::Body<'tcx>) {
         let body_id = body.id();
         let owner_id = self.tcx.hir_body_owner_def_id(body_id);
 
@@ -783,7 +783,7 @@ impl<'tcx> Visitor<'tcx> for ScopeResolutionVisitor<'tcx> {
                 }
 
                 // The body of the every fn is a root scope.
-                resolve_expr(this, &body.value, true);
+                resolve_expr(this, body.value, true);
             } else {
                 // All bodies have an outer temporary drop scope, but temporaries
                 // and `super let` bindings in constant initializers may be extended
@@ -808,7 +808,7 @@ impl<'tcx> Visitor<'tcx> for ScopeResolutionVisitor<'tcx> {
                     local_id: body.value.hir_id.local_id,
                     data: ScopeData::Destruction,
                 });
-                resolve_local(this, None, Some(&body.value), LetKind::Regular);
+                resolve_local(this, None, Some(body.value), LetKind::Regular);
             }
         })
     }

compiler/rustc_hir_analysis/src/collect.rs

@@ -1705,7 +1705,7 @@ fn coroutine_for_closure(tcx: TyCtxt<'_>, def_id: LocalDefId) -> DefId {
         bug!()
     };
 
-    let hir::Expr {
+    let &hir::Expr {
         kind:
             hir::ExprKind::Closure(&rustc_hir::Closure {
                 def_id,

compiler/rustc_hir_pretty/src/lib.rs

@@ -63,7 +63,7 @@ impl PpAnn for &dyn rustc_hir::intravisit::HirTyCtxt<'_> {
             Nested::TraitItem(id) => state.print_trait_item(self.hir_trait_item(id)),
             Nested::ImplItem(id) => state.print_impl_item(self.hir_impl_item(id)),
             Nested::ForeignItem(id) => state.print_foreign_item(self.hir_foreign_item(id)),
-            Nested::Body(id) => state.print_expr(&self.hir_body(id).value),
+            Nested::Body(id) => state.print_expr(self.hir_body(id).value),
             Nested::BodyParamPat(id, i) => state.print_pat(self.hir_body(id).params[i].pat),
         }
     }

compiler/rustc_hir_typeck/src/check.rs

@@ -127,7 +127,7 @@ pub(super) fn check_fn<'a, 'tcx>(
     }
 
     fcx.is_whole_body.set(true);
-    fcx.check_return_or_body_tail(&body.value, false);
+    fcx.check_return_or_body_tail(body.value, false);
 
     // Finalize the return check by taking the LUB of the return types
     // we saw and assigning it to the expected return type. This isn't

compiler/rustc_hir_typeck/src/demand.rs

@@ -332,7 +332,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let mut expr_finder = FindExprs { hir_id: local_hir_id, uses: init.into_iter().collect() };
         let body = self.tcx.hir_body_owned_by(self.body_def_id);
-        expr_finder.visit_expr(&body.value);
+        expr_finder.visit_expr(body.value);
 
         // Replaces all of the variables in the given type with a fresh inference variable.
         let mut fudger = BottomUpFolder {

compiler/rustc_hir_typeck/src/expr.rs

@@ -1746,7 +1746,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let def_id = block.def_id;
         let fcx = FnCtxt::new(self, self.param_env, def_id);
 
-        let ty = fcx.check_expr_with_expectation(&body.value, expected);
+        let ty = fcx.check_expr_with_expectation(body.value, expected);
         fcx.require_type_is_sized(ty, body.value.span, ObligationCauseCode::SizedConstOrStatic);
         fcx.write_ty(block.hir_id, ty);
         ty
@@ -3761,7 +3761,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let body = self.tcx.hir_body(anon_const.body);
 
                     let fcx = FnCtxt::new(self, self.param_env, anon_const.def_id);
-                    let ty = fcx.check_expr(&body.value);
+                    let ty = fcx.check_expr(body.value);
                     let target_ty = match self.structurally_resolve_type(body.value.span, ty).kind()
                     {
                         ty::FnDef(..) => {

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -316,7 +316,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
             self.walk_pat(&param_place, param.pat, false)?;
         }
 
-        self.consume_expr(&body.value)?;
+        self.consume_expr(body.value)?;
 
         Ok(())
     }

compiler/rustc_hir_typeck/src/fallback.rs

@@ -341,7 +341,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                 let reachable_vids =
                     graph::depth_first_search_as_undirected(coercions, vid).collect();
                 AnnotateUnitFallbackVisitor { reachable_vids, fcx: self }
-                    .visit_expr(&body.value)
+                    .visit_expr(body.value)
                     .break_value()
             })
             .collect();

compiler/rustc_hir_typeck/src/inline_asm.rs

@@ -583,7 +583,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
                     }
                 }
                 hir::InlineAsmOperand::Const { anon_const } => {
-                    let ty = self.expr_ty(&self.tcx().hir_body(anon_const.body).value);
+                    let ty = self.expr_ty(self.tcx().hir_body(anon_const.body).value);
                     match ty.kind() {
                         ty::Error(_) => {}
                         _ if ty.is_integral() => {}

compiler/rustc_hir_typeck/src/lib.rs

@@ -133,7 +133,7 @@ fn typeck_with_inspect<'tcx>(
     if let hir::Node::Item(hir::Item { kind: hir::ItemKind::GlobalAsm { .. }, .. }) = node {
         // Check the fake body of a global ASM. There's not much to do here except
         // for visit the asm expr of the body.
-        let ty = fcx.check_expr(&body.value);
+        let ty = fcx.check_expr(body.value);
         fcx.write_ty(id, ty);
     } else if let Some(hir::FnSig { header, decl, span: _ }) = node.fn_sig() {
         let fn_sig = if decl.output.is_suggestable_infer_ty().is_some() {
@@ -204,7 +204,7 @@ fn typeck_with_inspect<'tcx>(
             );
         }
 
-        fcx.check_expr_coercible_to_type_or_error(&body.value, expected_type, None, |err, _| {
+        fcx.check_expr_coercible_to_type_or_error(body.value, expected_type, None, |err, _| {
             extend_err_with_const_context(err, tcx, node, expected_type);
         });
 

compiler/rustc_hir_typeck/src/upvar.rs

@@ -575,7 +575,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // for the inner coroutine may actually be more restrictive.
                 if infer_kind {
                     let ty::Coroutine(_, coroutine_args) =
-                        *self.typeck_results.borrow().expr_ty(&body.value).kind()
+                        *self.typeck_results.borrow().expr_ty(body.value).kind()
                     else {
                         bug!();
                     };

compiler/rustc_lint/src/async_closures.rs

@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for AsyncClosureUsage {
             return;
         };
 
-        let mut body = &cx.tcx.hir_body(body).value;
+        let mut body = cx.tcx.hir_body(body).value;
 
         // Only peel blocks that have no expressions.
         while let hir::ExprKind::Block(&hir::Block { stmts: [], expr: Some(tail), .. }, None) =

compiler/rustc_lint/src/context.rs

@@ -924,7 +924,7 @@ impl<'tcx> LateContext<'tcx> {
                 hir::Node::Item(item) => match item.kind {
                     // FIXME(mgca): figure out how to handle ConstArgKind::Path (or don't but add warning in docs here)
                     hir::ItemKind::Const(.., hir::ConstItemRhs::Body(body_id))
-                    | hir::ItemKind::Static(.., body_id) => Some(&self.tcx.hir_body(body_id).value),
+                    | hir::ItemKind::Static(.., body_id) => Some(self.tcx.hir_body(body_id).value),
                     _ => None,
                 },
                 _ => None,

compiler/rustc_lint/src/for_loops_over_fallibles.rs

@@ -165,7 +165,7 @@ fn suggest_question_mark<'tcx>(
     // Check that the function/closure/constant we are in has a `Result` type.
     // Otherwise suggesting using `?` may not be a good idea.
     {
-        let ty = cx.typeck_results().expr_ty(&cx.tcx.hir_body(body_id).value);
+        let ty = cx.typeck_results().expr_ty(cx.tcx.hir_body(body_id).value);
         let ty::Adt(ret_adt, ..) = ty.kind() else { return false };
         if !cx.tcx.is_diagnostic_item(sym::Result, ret_adt.did()) {
             return false;

compiler/rustc_lint/src/late.rs

@@ -122,7 +122,7 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
         });
     }
 
-    fn visit_body(&mut self, body: &'tcx hir::Body<'tcx>) {
+    fn visit_body(&mut self, body: &hir::Body<'tcx>) {
         lint_callback!(self, check_body, body);
         hir_visit::walk_body(self, body);
         lint_callback!(self, check_body_post, body);

compiler/rustc_lint/src/passes.rs

@@ -7,8 +7,8 @@ macro_rules! late_lint_methods {
     ($macro:path, $args:tt) => (
         // `_post` methods are called *after* recursing into the node.
         $macro!($args, [
-            fn check_body(a: &'tcx rustc_hir::Body<'tcx>);
-            fn check_body_post(a: &'tcx rustc_hir::Body<'tcx>);
+            fn check_body(a: &rustc_hir::Body<'tcx>);
+            fn check_body_post(a: &rustc_hir::Body<'tcx>);
             fn check_crate();
             fn check_crate_post();
             fn check_mod(a: &'tcx rustc_hir::Mod<'tcx>, b: rustc_span::def_id::LocalModId);

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -2861,7 +2861,7 @@ pub(crate) fn provide(providers: &mut Providers) {
 /// use a different method for pretty-printing. Ideally this function
 /// should only ever be used as a fallback.
 pub fn rendered_const<'tcx>(tcx: TyCtxt<'tcx>, body: &hir::Body<'_>, def_id: LocalDefId) -> String {
-    let value = &body.value;
+    let value = body.value;
 
     #[derive(PartialEq, Eq)]
     enum Classification {

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

@@ -53,7 +53,7 @@ pub(crate) fn thir_body<'tcx>(
         }
     }
 
-    let expr = cx.mirror_expr(&body.value);
+    let expr = cx.mirror_expr(body.value);
     Ok((tcx.alloc_steal_thir(cx.thir), expr))
 }
 

compiler/rustc_mir_transform/src/coverage/hir_info.rs

@@ -99,10 +99,7 @@ fn hash_mir_source<'tcx>(tcx: TyCtxt<'tcx>, hir_body: &'tcx hir::Body<'tcx>) ->
         .as_u64()
 }
 
-fn extract_hole_spans_from_hir<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    hir_body: &'tcx hir::Body<'tcx>,
-) -> Vec<Span> {
+fn extract_hole_spans_from_hir<'tcx>(tcx: TyCtxt<'tcx>, hir_body: &hir::Body<'tcx>) -> Vec<Span> {
     struct HolesVisitor<'tcx> {
         tcx: TyCtxt<'tcx>,
         hole_spans: Vec<Span>,
@@ -159,7 +156,7 @@ fn extract_hole_spans_from_hir<'tcx>(
 fn find_nodes_to_ignore<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
-    hir_body: &'tcx hir::Body<'tcx>,
+    hir_body: &hir::Body<'tcx>,
 ) -> FxHashSet<HirId> {
     /// Top-level visitor used by [`find_nodes_to_ignore`].
     struct FindNodesToIgnoreVisitor<'tcx> {

compiler/rustc_passes/src/input_stats.rs

@@ -272,7 +272,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_item(self, i)
     }
 
-    fn visit_body(&mut self, b: &'v hir::Body<'v>) {
+    fn visit_body(&mut self, b: &hir::Body<'v>) {
         self.record("Body", None, b);
         hir_visit::walk_body(self, b);
     }

compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs

@@ -522,7 +522,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         if let Some(body) =
             self.tcx.hir_maybe_body_owned_by(self.tcx.typeck_root_def_id_local(body_def_id))
         {
-            let expr = &body.value;
+            let expr = body.value;
             local_visitor.visit_expr(expr);
             body_from_expansion = body.value.span.from_expansion();
         }
@@ -1380,7 +1380,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> {
 
     /// For closures, we first visit the parameters and then the content,
     /// as we prefer those.
-    fn visit_body(&mut self, body: &'tcx Body<'tcx>) {
+    fn visit_body(&mut self, body: &Body<'tcx>) {
         for param in body.params {
             debug!(
                 "param: span {:?}, ty_span {:?}, pat.span {:?}",