return a TempLifetime from ScopeTree::temporary_scope

This means less boilerplate when building the THIR and less possibility
for confusion about what to do with the returned scopes from
`ScopeTree::temporary_scope`. Possibly migrating `TempLifetime` to
`rustc_middle::middle::region` and tweaking its doc comments is left for
future work.

Author: dianne

compiler/rustc_middle/src/middle/region.rs

@@ -16,6 +16,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::{DUMMY_SP, Span};
 use tracing::debug;
 
+use crate::thir::TempLifetime;
 use crate::ty::{self, TyCtxt};
 
 /// Represents a statically-describable scope that can be used to
@@ -332,16 +333,16 @@ impl ScopeTree {
     /// Returns the scope when the temp created by `expr_id` will be cleaned up.
     /// It also emits a lint on potential backwards incompatible change to the temporary scope
     /// which is *for now* always shortening.
-    pub fn temporary_scope(&self, expr_id: hir::ItemLocalId) -> (Option<Scope>, Option<Scope>) {
+    pub fn temporary_scope(&self, expr_id: hir::ItemLocalId) -> TempLifetime {
         // Check for a designated extended temporary scope.
-        if let Some(&s) = self.extended_temp_scopes.get(&expr_id) {
+        if let Some(&s) = self.rvalue_scopes.get(&expr_id) {
             debug!("temporary_scope({expr_id:?}) = {s:?} [custom]");
-            return (s, None);
+            return TempLifetime { temp_lifetime: s, backwards_incompatible: None };
         }
 
         // Otherwise, locate the innermost terminating scope.
-        let (scope, backward_incompatible) =
+        let (scope, backwards_incompatible) =
             self.default_temporary_scope(Scope { local_id: expr_id, data: ScopeData::Node });
-        (Some(scope), backward_incompatible)
+        TempLifetime { temp_lifetime: Some(scope), backwards_incompatible }
     }
 }

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

@@ -336,8 +336,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
     fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx> {
         let tcx = self.tcx;
         let expr_ty = self.typeck_results.expr_ty(expr);
-        let (temp_lifetime, backwards_incompatible) =
-            self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
 
         let kind = match expr.kind {
             // Here comes the interesting stuff:
@@ -372,7 +371,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
                     let arg_tys = args.iter().map(|e| self.typeck_results.expr_ty_adjusted(e));
                     let tupled_args = Expr {
                         ty: Ty::new_tup_from_iter(tcx, arg_tys),
-                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                        temp_lifetime,
                         span: expr.span,
                         kind: ExprKind::Tuple { fields: self.mirror_exprs(args) },
                     };
@@ -398,7 +397,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
                     }
                     let value = &args[0];
                     return Expr {
-                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                        temp_lifetime,
                         ty: expr_ty,
                         span: expr.span,
                         kind: ExprKind::Box { value: self.mirror_expr(value) },
@@ -502,17 +501,17 @@ impl<'tcx> ThirBuildCx<'tcx> {
                             expr: Some(arg),
                             safety_mode: BlockSafety::Safe,
                         });
-                        let (temp_lifetime, backwards_incompatible) =
-                            self.region_scope_tree.temporary_scope(arg_expr.hir_id.local_id);
                         arg = self.thir.exprs.push(Expr {
-                            temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                            temp_lifetime: self
+                                .region_scope_tree
+                                .temporary_scope(arg_expr.hir_id.local_id),
                             ty: arg_ty,
                             span: arg_expr.span,
                             kind: ExprKind::Block { block },
                         });
                     }
                     let expr = self.thir.exprs.push(Expr {
-                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                        temp_lifetime,
                         ty,
                         span: expr.span,
                         kind: ExprKind::Borrow { borrow_kind: mutbl.to_borrow_kind(), arg },
@@ -995,12 +994,10 @@ impl<'tcx> ThirBuildCx<'tcx> {
                     }
                 } else {
                     let block_ty = self.typeck_results.node_type(body.hir_id);
-                    let (temp_lifetime, backwards_incompatible) =
-                        self.region_scope_tree.temporary_scope(body.hir_id.local_id);
                     let block = self.mirror_block(body);
                     let body = self.thir.exprs.push(Expr {
                         ty: block_ty,
-                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                        temp_lifetime: self.region_scope_tree.temporary_scope(body.hir_id.local_id),
                         span: self.thir[block].span,
                         kind: ExprKind::Block { block },
                     });
@@ -1022,17 +1019,13 @@ impl<'tcx> ThirBuildCx<'tcx> {
                     expr, cast_ty.hir_id, user_ty,
                 );
 
-                let cast = self.mirror_expr_cast(
-                    source,
-                    TempLifetime { temp_lifetime, backwards_incompatible },
-                    expr.span,
-                );
+                let cast = self.mirror_expr_cast(source, temp_lifetime, expr.span);
 
                 if let Some(user_ty) = user_ty {
                     // NOTE: Creating a new Expr and wrapping a Cast inside of it may be
                     //       inefficient, revisit this when performance becomes an issue.
                     let cast_expr = self.thir.exprs.push(Expr {
-                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                        temp_lifetime,
                         ty: expr_ty,
                         span: expr.span,
                         kind: cast,
@@ -1091,12 +1084,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
             hir::ExprKind::Err(_) => unreachable!("cannot lower a `hir::ExprKind::Err` to THIR"),
         };
 
-        Expr {
-            temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
-            ty: expr_ty,
-            span: expr.span,
-            kind,
-        }
+        Expr { temp_lifetime, ty: expr_ty, span: expr.span, kind }
     }
 
     fn user_args_applied_to_res(
@@ -1140,8 +1128,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
         span: Span,
         overloaded_callee: Option<Ty<'tcx>>,
     ) -> Expr<'tcx> {
-        let (temp_lifetime, backwards_incompatible) =
-            self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
         let (ty, user_ty) = match overloaded_callee {
             Some(fn_def) => (fn_def, None),
             None => {
@@ -1157,12 +1144,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 )
             }
         };
-        Expr {
-            temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
-            ty,
-            span,
-            kind: ExprKind::ZstLiteral { user_ty },
-        }
+        Expr { temp_lifetime, ty, span, kind: ExprKind::ZstLiteral { user_ty } }
     }
 
     fn convert_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) -> ArmId {
@@ -1235,21 +1217,15 @@ impl<'tcx> ThirBuildCx<'tcx> {
             Res::Def(DefKind::Static { .. }, id) => {
                 // this is &raw for extern static or static mut, and & for other statics
                 let ty = self.tcx.static_ptr_ty(id, self.typing_env);
-                let (temp_lifetime, backwards_incompatible) =
-                    self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+                let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
                 let kind = if self.tcx.is_thread_local_static(id) {
                     ExprKind::ThreadLocalRef(id)
                 } else {
                     let alloc_id = self.tcx.reserve_and_set_static_alloc(id);
                     ExprKind::StaticRef { alloc_id, ty, def_id: id }
                 };
                 ExprKind::Deref {
-                    arg: self.thir.exprs.push(Expr {
-                        ty,
-                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
-                        span: expr.span,
-                        kind,
-                    }),
+                    arg: self.thir.exprs.push(Expr { ty, temp_lifetime, span: expr.span, kind }),
                 }
             }
 
@@ -1317,13 +1293,12 @@ impl<'tcx> ThirBuildCx<'tcx> {
 
         // construct the complete expression `foo()` for the overloaded call,
         // which will yield the &T type
-        let (temp_lifetime, backwards_incompatible) =
-            self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
         let fun = self.method_callee(expr, span, overloaded_callee);
         let fun = self.thir.exprs.push(fun);
         let fun_ty = self.thir[fun].ty;
         let ref_expr = self.thir.exprs.push(Expr {
-            temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+            temp_lifetime,
             ty: ref_ty,
             span,
             kind: ExprKind::Call { ty: fun_ty, fun, args, from_hir_call: false, fn_span: span },
@@ -1338,8 +1313,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
         closure_expr: &'tcx hir::Expr<'tcx>,
         place: HirPlace<'tcx>,
     ) -> Expr<'tcx> {
-        let (temp_lifetime, backwards_incompatible) =
-            self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
         let var_ty = place.base_ty;
 
         // The result of capture analysis in `rustc_hir_typeck/src/upvar.rs` represents a captured path
@@ -1353,7 +1327,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
         };
 
         let mut captured_place_expr = Expr {
-            temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+            temp_lifetime,
             ty: var_ty,
             span: closure_expr.span,
             kind: self.convert_var(var_hir_id),
@@ -1381,12 +1355,8 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 }
             };
 
-            captured_place_expr = Expr {
-                temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
-                ty: proj.ty,
-                span: closure_expr.span,
-                kind,
-            };
+            captured_place_expr =
+                Expr { temp_lifetime, ty: proj.ty, span: closure_expr.span, kind };
         }
 
         captured_place_expr
@@ -1401,8 +1371,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
         let upvar_capture = captured_place.info.capture_kind;
         let captured_place_expr =
             self.convert_captured_hir_place(closure_expr, captured_place.place.clone());
-        let (temp_lifetime, backwards_incompatible) =
-            self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
 
         match upvar_capture {
             ty::UpvarCapture::ByValue => captured_place_expr,
@@ -1411,7 +1380,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 let expr_id = self.thir.exprs.push(captured_place_expr);
 
                 Expr {
-                    temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                    temp_lifetime,
                     ty: upvar_ty,
                     span: closure_expr.span,
                     kind: ExprKind::ByUse { expr: expr_id, span },
@@ -1428,7 +1397,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
                     }
                 };
                 Expr {
-                    temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                    temp_lifetime,
                     ty: upvar_ty,
                     span: closure_expr.span,
                     kind: ExprKind::Borrow {