Auto merge of rust-lang#125923 - matthewjasper:no-return-leak, r=<try>

Fix leaks from panics in destructors

Resurrects rust-lang#78373.

This avoids the problem with rust-lang#80949 by not unscheduling drops of function arguments until after the call (so they still get a drop terminator on the function unwind path).

Closes rust-lang#47949

r? `@lcnr`

Author: bors

compiler/rustc_mir_build/src/build/block.rs

@@ -11,6 +11,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     pub(crate) fn ast_block(
         &mut self,
         destination: Place<'tcx>,
+        scope: Option<Scope>,
         block: BasicBlock,
         ast_block: BlockId,
         source_info: SourceInfo,
@@ -19,18 +20,27 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             self.thir[ast_block];
         self.in_scope((region_scope, source_info), LintLevel::Inherited, move |this| {
             if targeted_by_break {
-                this.in_breakable_scope(None, destination, span, |this| {
-                    Some(this.ast_block_stmts(destination, block, span, stmts, expr, region_scope))
+                this.in_breakable_scope(None, destination, scope, span, |this| {
+                    Some(this.ast_block_stmts(
+                        destination,
+                        scope,
+                        block,
+                        span,
+                        stmts,
+                        expr,
+                        region_scope,
+                    ))
                 })
             } else {
-                this.ast_block_stmts(destination, block, span, stmts, expr, region_scope)
+                this.ast_block_stmts(destination, scope, block, span, stmts, expr, region_scope)
             }
         })
     }
 
     fn ast_block_stmts(
         &mut self,
         destination: Place<'tcx>,
+        scope: Option<Scope>,
         mut block: BasicBlock,
         span: Span,
         stmts: &[StmtId],
@@ -168,6 +178,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     unpack!(
                         failure_block = this.ast_block(
                             dummy_place,
+                            None,
                             failure_entry,
                             *else_block,
                             this.source_info(else_block_span),
@@ -321,7 +332,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             this.block_context
                 .push(BlockFrame::TailExpr { tail_result_is_ignored, span: expr.span });
 
-            unpack!(block = this.expr_into_dest(destination, block, expr_id));
+            unpack!(block = this.expr_into_dest(destination, scope, block, expr_id));
             let popped = this.block_context.pop();
 
             assert!(popped.is_some_and(|bf| bf.is_tail_expr()));

compiler/rustc_mir_build/src/build/expr/as_rvalue.rs

@@ -20,6 +20,8 @@ use rustc_middle::ty::{self, Ty, UpvarArgs};
 use rustc_span::{Span, DUMMY_SP};
 use tracing::debug;
 
+use std::slice;
+
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Returns an rvalue suitable for use until the end of the current
     /// scope expression.
@@ -183,15 +185,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let box_ = Rvalue::ShallowInitBox(Operand::Move(storage), value_ty);
                 this.cfg.push_assign(block, source_info, Place::from(result), box_);
 
-                // initialize the box contents:
+                // Initialize the box contents. No scope is needed since the
+                // `Box` is already scheduled to be dropped.
                 unpack!(
                     block = this.expr_into_dest(
                         this.tcx.mk_place_deref(Place::from(result)),
+                        None,
                         block,
                         value,
                     )
                 );
-                block.and(Rvalue::Use(Operand::Move(Place::from(result))))
+                let result_operand = Operand::Move(Place::from(result));
+                this.record_operands_moved(slice::from_ref(&result_operand));
+                block.and(Rvalue::Use(result_operand))
             }
             ExprKind::Cast { source } => {
                 let source_expr = &this.thir[source];
@@ -359,6 +365,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     })
                     .collect();
 
+                this.record_operands_moved(&fields.raw);
                 block.and(Rvalue::Aggregate(Box::new(AggregateKind::Array(el_ty)), fields))
             }
             ExprKind::Tuple { ref fields } => {
@@ -380,6 +387,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     })
                     .collect();
 
+                this.record_operands_moved(&fields.raw);
                 block.and(Rvalue::Aggregate(Box::new(AggregateKind::Tuple), fields))
             }
             ExprKind::Closure(box ClosureExpr {
@@ -482,6 +490,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         Box::new(AggregateKind::CoroutineClosure(closure_id.to_def_id(), args))
                     }
                 };
+                this.record_operands_moved(&operands.raw);
                 block.and(Rvalue::Aggregate(result, operands))
             }
             ExprKind::Assign { .. } | ExprKind::AssignOp { .. } => {
@@ -737,7 +746,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.diverge_from(block);
                 block = success;
             }
-            this.record_operands_moved(&[Spanned { node: value_operand, span: DUMMY_SP }]);
+            this.record_operands_moved(&[value_operand]);
         }
         block.and(Rvalue::Aggregate(Box::new(AggregateKind::Array(elem_ty)), IndexVec::new()))
     }

compiler/rustc_mir_build/src/build/expr/as_temp.rs

@@ -112,11 +112,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
         }
 
-        unpack!(block = this.expr_into_dest(temp_place, block, expr_id));
-
-        if let Some(temp_lifetime) = temp_lifetime {
-            this.schedule_drop(expr_span, temp_lifetime, temp, DropKind::Value);
-        }
+        unpack!(block = this.expr_into_dest(temp_place, temp_lifetime, block, expr_id));
 
         block.and(temp)
     }

compiler/rustc_mir_build/src/build/expr/into.rs

@@ -1,11 +1,14 @@
 //! See docs in build/expr/mod.rs
 
 use crate::build::expr::category::{Category, RvalueFunc};
+use crate::build::scope::DropKind;
 use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder, NeedsTemporary};
 use rustc_ast::InlineAsmOptions;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir as hir;
+use rustc_index::IndexVec;
+use rustc_middle::middle::region;
 use rustc_middle::mir::*;
 use rustc_middle::span_bug;
 use rustc_middle::thir::*;
@@ -14,13 +17,16 @@ use rustc_span::source_map::Spanned;
 use std::iter;
 use tracing::{debug, instrument};
 
+use std::slice;
+
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Compile `expr`, storing the result into `destination`, which
     /// is assumed to be uninitialized.
     #[instrument(level = "debug", skip(self))]
     pub(crate) fn expr_into_dest(
         &mut self,
         destination: Place<'tcx>,
+        scope: Option<region::Scope>,
         mut block: BasicBlock,
         expr_id: ExprId,
     ) -> BlockAnd<()> {
@@ -35,6 +41,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let expr_is_block_or_scope =
             matches!(expr.kind, ExprKind::Block { .. } | ExprKind::Scope { .. });
 
+        let schedule_drop = move |this: &mut Self| {
+            if let Some(drop_scope) = scope {
+                let local =
+                    destination.as_local().expect("cannot schedule drop of non-Local place");
+                this.schedule_drop(expr_span, drop_scope, local, DropKind::Value);
+            }
+        };
+
         if !expr_is_block_or_scope {
             this.block_context.push(BlockFrame::SubExpr);
         }
@@ -44,15 +58,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let region_scope = (region_scope, source_info);
                 ensure_sufficient_stack(|| {
                     this.in_scope(region_scope, lint_level, |this| {
-                        this.expr_into_dest(destination, block, value)
+                        this.expr_into_dest(destination, scope, block, value)
                     })
                 })
             }
             ExprKind::Block { block: ast_block } => {
-                this.ast_block(destination, block, ast_block, source_info)
+                this.ast_block(destination, scope, block, ast_block, source_info)
             }
             ExprKind::Match { scrutinee, ref arms, .. } => this.match_expr(
                 destination,
+                scope,
                 block,
                 scrutinee,
                 arms,
@@ -90,7 +105,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                 ));
 
                                 // Lower the `then` arm into its block.
-                                this.expr_into_dest(destination, then_blk, then)
+                                let then_blk =
+                                    this.expr_into_dest(destination, scope, then_blk, then);
+                                if let Some(drop_scope) = scope {
+                                    let local = destination
+                                        .as_local()
+                                        .expect("cannot unschedule drop of non-Local place");
+                                    this.unschedule_drop(drop_scope, local);
+                                }
+                                then_blk
                             });
 
                         // Pack `(then_block, else_block)` into `BlockAnd<BasicBlock>`.
@@ -104,7 +127,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 // If there is an `else` arm, lower it into `else_blk`.
                 if let Some(else_expr) = else_opt {
-                    unpack!(else_blk = this.expr_into_dest(destination, else_blk, else_expr));
+                    unpack!(
+                        else_blk = this.expr_into_dest(destination, scope, else_blk, else_expr)
+                    );
                 } else {
                     // There is no `else` arm, so we know both arms have type `()`.
                     // Generate the implicit `else {}` by assigning unit.
@@ -139,6 +164,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 // This is an optimization. If the expression was a call then we already have an
                 // unreachable block. Don't bother to terminate it and create a new one.
+                schedule_drop(this);
                 if is_call {
                     block.unit()
                 } else {
@@ -183,7 +209,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         const_: Const::from_bool(this.tcx, constant),
                     },
                 );
-                let mut rhs_block = unpack!(this.expr_into_dest(destination, continuation, rhs));
+                let mut rhs_block =
+                    unpack!(this.expr_into_dest(destination, scope, continuation, rhs));
                 // Instrument the lowered RHS's value for condition coverage.
                 // (Does nothing if condition coverage is not enabled.)
                 this.visit_coverage_standalone_condition(rhs, destination, &mut rhs_block);
@@ -209,53 +236,60 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // Start the loop.
                 this.cfg.goto(block, source_info, loop_block);
 
-                this.in_breakable_scope(Some(loop_block), destination, expr_span, move |this| {
-                    // conduct the test, if necessary
-                    let body_block = this.cfg.start_new_block();
-                    this.cfg.terminate(
-                        loop_block,
-                        source_info,
-                        TerminatorKind::FalseUnwind {
-                            real_target: body_block,
-                            unwind: UnwindAction::Continue,
-                        },
-                    );
-                    this.diverge_from(loop_block);
-
-                    // The “return” value of the loop body must always be a unit. We therefore
-                    // introduce a unit temporary as the destination for the loop body.
-                    let tmp = this.get_unit_temp();
-                    // Execute the body, branching back to the test.
-                    let body_block_end = unpack!(this.expr_into_dest(tmp, body_block, body));
-                    this.cfg.goto(body_block_end, source_info, loop_block);
-
-                    // Loops are only exited by `break` expressions.
-                    None
-                })
+                this.in_breakable_scope(
+                    Some(loop_block),
+                    destination,
+                    scope,
+                    expr_span,
+                    move |this| {
+                        // conduct the test, if necessary
+                        let body_block = this.cfg.start_new_block();
+                        this.cfg.terminate(
+                            loop_block,
+                            source_info,
+                            TerminatorKind::FalseUnwind {
+                                real_target: body_block,
+                                unwind: UnwindAction::Continue,
+                            },
+                        );
+                        this.diverge_from(loop_block);
+
+                        // The “return” value of the loop body must always be a unit. We therefore
+                        // introduce a unit temporary as the destination for the loop body.
+                        let tmp = this.get_unit_temp();
+                        // Execute the body, branching back to the test.
+                        let body_block_end =
+                            unpack!(this.expr_into_dest(tmp, scope, body_block, body));
+                        this.cfg.goto(body_block_end, source_info, loop_block);
+                        schedule_drop(this);
+
+                        // Loops are only exited by `break` expressions.
+                        None
+                    },
+                )
             }
             ExprKind::Call { ty: _, fun, ref args, from_hir_call, fn_span } => {
                 let fun = unpack!(block = this.as_local_operand(block, fun));
-                let args: Vec<_> = args
+                let spanned_args: Vec<_> = args
                     .into_iter()
                     .copied()
                     .map(|arg| Spanned {
                         node: unpack!(block = this.as_local_call_operand(block, arg)),
                         span: this.thir.exprs[arg].span,
                     })
                     .collect();
+                let args: Vec<_> = spanned_args.iter().map(|arg| arg.node.clone()).collect();
 
                 let success = this.cfg.start_new_block();
 
-                this.record_operands_moved(&args);
-
                 debug!("expr_into_dest: fn_span={:?}", fn_span);
 
                 this.cfg.terminate(
                     block,
                     source_info,
                     TerminatorKind::Call {
                         func: fun,
-                        args,
+                        args: spanned_args,
                         unwind: UnwindAction::Continue,
                         destination,
                         // The presence or absence of a return edge affects control-flow sensitive
@@ -275,9 +309,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     },
                 );
                 this.diverge_from(block);
+
+                // This is here and not before `diverge_from` to avoid breaking
+                // the example in #80949.
+                // FIXME(matthewjasper): Look at this again if Polonius is
+                // stabilized.
+                this.record_operands_moved(&args);
+                schedule_drop(this);
                 success.unit()
             }
-            ExprKind::Use { source } => this.expr_into_dest(destination, block, source),
+            ExprKind::Use { source } => this.expr_into_dest(destination, scope, block, source),
             ExprKind::Borrow { arg, borrow_kind } => {
                 // We don't do this in `as_rvalue` because we use `as_place`
                 // for borrow expressions, so we cannot create an `RValue` that
@@ -340,7 +381,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 let field_names = adt_def.variant(variant_index).fields.indices();
 
-                let fields = if let Some(FruInfo { base, field_types }) = base {
+                let fields: IndexVec<_, _> = if let Some(FruInfo { base, field_types }) = base {
                     let place_builder = unpack!(block = this.as_place_builder(block, *base));
 
                     // MIR does not natively support FRU, so for each
@@ -374,12 +415,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     user_ty,
                     active_field_index,
                 ));
+                this.record_operands_moved(&fields.raw);
                 this.cfg.push_assign(
                     block,
                     source_info,
                     destination,
                     Rvalue::Aggregate(adt, fields),
                 );
+                schedule_drop(this);
                 block.unit()
             }
             ExprKind::InlineAsm(box InlineAsmExpr {
@@ -458,7 +501,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             targets.push(target);
 
                             let tmp = this.get_unit_temp();
-                            let target = unpack!(this.ast_block(tmp, target, block, source_info));
+                            let target =
+                                unpack!(this.ast_block(tmp, scope, target, block, source_info));
                             this.cfg.terminate(
                                 target,
                                 source_info,
@@ -522,6 +566,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let place = unpack!(block = this.as_place(block, expr_id));
                 let rvalue = Rvalue::Use(this.consume_by_copy_or_move(place));
                 this.cfg.push_assign(block, source_info, destination, rvalue);
+                schedule_drop(this);
                 block.unit()
             }
             ExprKind::Index { .. } | ExprKind::Deref { .. } | ExprKind::Field { .. } => {
@@ -537,6 +582,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let place = unpack!(block = this.as_place(block, expr_id));
                 let rvalue = Rvalue::Use(this.consume_by_copy_or_move(place));
                 this.cfg.push_assign(block, source_info, destination, rvalue);
+                schedule_drop(this);
                 block.unit()
             }
 
@@ -552,12 +598,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     )
                 );
                 let resume = this.cfg.start_new_block();
+                this.record_operands_moved(slice::from_ref(&value));
                 this.cfg.terminate(
                     block,
                     source_info,
                     TerminatorKind::Yield { value, resume, resume_arg: destination, drop: None },
                 );
                 this.coroutine_drop_cleanup(block);
+                schedule_drop(this);
                 resume.unit()
             }
 
@@ -594,6 +642,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 let rvalue = unpack!(block = this.as_local_rvalue(block, expr_id));
                 this.cfg.push_assign(block, source_info, destination, rvalue);
+                schedule_drop(this);
                 block.unit()
             }
         };

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -297,6 +297,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     pub(crate) fn match_expr(
         &mut self,
         destination: Place<'tcx>,
+        destination_scope: Option<region::Scope>,
         mut block: BasicBlock,
         scrutinee_id: ExprId,
         arms: &[ArmId],
@@ -325,6 +326,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         self.lower_match_arms(
             destination,
+            destination_scope,
             scrutinee_place,
             scrutinee_span,
             arm_candidates,
@@ -461,20 +463,43 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// (by [Builder::lower_match_tree]).
     ///
     /// `outer_source_info` is the SourceInfo for the whole match.
+    /// [Builder::lower_match_tree]).
     fn lower_match_arms(
         &mut self,
         destination: Place<'tcx>,
+        destination_scope: Option<region::Scope>,
         scrutinee_place_builder: PlaceBuilder<'tcx>,
         scrutinee_span: Span,
         arm_candidates: Vec<(&'_ Arm<'tcx>, Candidate<'_, 'tcx>)>,
         outer_source_info: SourceInfo,
         fake_borrow_temps: Vec<(Place<'tcx>, Local, FakeBorrowKind)>,
     ) -> BlockAnd<()> {
+        if arm_candidates.is_empty() {
+            // If there are no arms to schedule drops, then we have to do it
+            // manually.
+            if let Some(scope) = destination_scope {
+                self.schedule_drop(
+                    outer_source_info.span,
+                    scope,
+                    destination.as_local().unwrap(),
+                    DropKind::Value,
+                );
+            }
+            return self.cfg.start_new_block().unit();
+        }
+
+        let mut first_arm = true;
         let arm_end_blocks: Vec<_> = arm_candidates
             .into_iter()
             .map(|(arm, candidate)| {
                 debug!("lowering arm {:?}\ncandidate = {:?}", arm, candidate);
 
+                if first_arm {
+                    first_arm = false;
+                } else if let Some(scope) = destination_scope {
+                    self.unschedule_drop(scope, destination.as_local().unwrap());
+                }
+
                 let arm_source_info = self.source_info(arm.span);
                 let arm_scope = (arm.scope, arm_source_info);
                 let match_scope = self.local_scope();
@@ -519,7 +544,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         this.source_scope = source_scope;
                     }
 
-                    this.expr_into_dest(destination, arm_block, arm.body)
+                    this.expr_into_dest(destination, destination_scope, arm_block, arm.body)
                 })
             })
             .collect();
@@ -635,13 +660,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             PatKind::Binding { mode: BindingMode(ByRef::No, _), var, subpattern: None, .. } => {
                 let place =
                     self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
-                unpack!(block = self.expr_into_dest(place, block, initializer_id));
+                let region_scope = self.region_scope_tree.var_scope(var.0.local_id);
+
+                unpack!(block = self.expr_into_dest(place, region_scope, block, initializer_id));
 
                 // Inject a fake read, see comments on `FakeReadCause::ForLet`.
                 let source_info = self.source_info(irrefutable_pat.span);
                 self.cfg.push_fake_read(block, source_info, FakeReadCause::ForLet(None), place);
 
-                self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard);
                 block.unit()
             }
 
@@ -667,9 +693,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     },
                 ascription: thir::Ascription { ref annotation, variance: _ },
             } => {
+                let region_scope = self.region_scope_tree.var_scope(var.0.local_id);
                 let place =
                     self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
-                unpack!(block = self.expr_into_dest(place, block, initializer_id));
+                unpack!(block = self.expr_into_dest(place, region_scope, block, initializer_id));
 
                 // Inject a fake read, see comments on `FakeReadCause::ForLet`.
                 let pattern_source_info = self.source_info(irrefutable_pat.span);
@@ -704,7 +731,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     },
                 );
 
-                self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard);
                 block.unit()
             }
 

compiler/rustc_mir_build/src/build/mod.rs

@@ -521,15 +521,21 @@ fn construct_fn<'tcx>(
         let arg_scope_s = (arg_scope, source_info);
         // Attribute epilogue to function's closing brace
         let fn_end = span_with_body.shrink_to_hi();
-        let return_block =
-            unpack!(builder.in_breakable_scope(None, Place::return_place(), fn_end, |builder| {
+        let return_block = unpack!(builder.in_breakable_scope(
+            None,
+            Place::return_place(),
+            Some(call_site_scope),
+            fn_end,
+            |builder| {
                 Some(builder.in_scope(arg_scope_s, LintLevel::Inherited, |builder| {
                     builder.args_and_body(START_BLOCK, arguments, arg_scope, expr)
                 }))
-            }));
+            },
+        ));
         let source_info = builder.source_info(fn_end);
         builder.cfg.terminate(return_block, source_info, TerminatorKind::Return);
         builder.build_drop_trees();
+        builder.unschedule_return_place_drop();
         return_block.unit()
     }));
 
@@ -577,7 +583,7 @@ fn construct_const<'a, 'tcx>(
         Builder::new(thir, infcx, def, hir_id, span, 0, const_ty, const_ty_span, None);
 
     let mut block = START_BLOCK;
-    unpack!(block = builder.expr_into_dest(Place::return_place(), block, expr));
+    unpack!(block = builder.expr_into_dest(Place::return_place(), None, block, expr));
 
     let source_info = builder.source_info(span);
     builder.cfg.terminate(block, source_info, TerminatorKind::Return);
@@ -974,7 +980,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             self.cfg.terminate(block, source_info, TerminatorKind::Unreachable);
             self.cfg.start_new_block().unit()
         } else {
-            self.expr_into_dest(Place::return_place(), block, expr_id)
+            let body = self.tcx.hir().body_owned_by(self.def_id);
+            let call_site_scope =
+                region::Scope { id: body.id().hir_id.local_id, data: region::ScopeData::CallSite };
+            self.expr_into_dest(Place::return_place(), Some(call_site_scope), block, expr_id)
         }
     }
 

compiler/rustc_mir_build/src/build/scope.rs

@@ -92,7 +92,6 @@ use rustc_middle::mir::*;
 use rustc_middle::thir::{ExprId, LintLevel};
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::Level;
-use rustc_span::source_map::Spanned;
 use rustc_span::{Span, DUMMY_SP};
 use tracing::{debug, instrument};
 
@@ -128,8 +127,6 @@ struct Scope {
     /// end of the vector (top of the stack) first.
     drops: Vec<DropData>,
 
-    moved_locals: Vec<Local>,
-
     /// The drop index that will drop everything in and below this scope on an
     /// unwind path.
     cached_unwind_block: Option<DropIdx>,
@@ -165,6 +162,8 @@ struct BreakableScope<'tcx> {
     /// The destination of the loop/block expression itself (i.e., where to put
     /// the result of a `break` or `return` expression)
     break_destination: Place<'tcx>,
+    /// The scope that the destination should have its drop scheduled in.
+    destination_scope: Option<region::Scope>,
     /// Drops that happen on the `break`/`return` path.
     break_drops: DropTree,
     /// Drops that happen on the `continue` path.
@@ -445,7 +444,6 @@ impl<'tcx> Scopes<'tcx> {
             source_scope: vis_scope,
             region_scope: region_scope.0,
             drops: vec![],
-            moved_locals: vec![],
             cached_unwind_block: None,
             cached_coroutine_drop_block: None,
         });
@@ -481,6 +479,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         &mut self,
         loop_block: Option<BasicBlock>,
         break_destination: Place<'tcx>,
+        destination_scope: Option<region::Scope>,
         span: Span,
         f: F,
     ) -> BlockAnd<()>
@@ -491,17 +490,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let scope = BreakableScope {
             region_scope,
             break_destination,
+            destination_scope,
             break_drops: DropTree::new(),
             continue_drops: loop_block.map(|_| DropTree::new()),
         };
+        let continue_block = loop_block.map(|block| (block, self.diverge_cleanup()));
         self.scopes.breakable_scopes.push(scope);
         let normal_exit_block = f(self);
         let breakable_scope = self.scopes.breakable_scopes.pop().unwrap();
         assert!(breakable_scope.region_scope == region_scope);
         let break_block =
             self.build_exit_tree(breakable_scope.break_drops, region_scope, span, None);
         if let Some(drops) = breakable_scope.continue_drops {
-            self.build_exit_tree(drops, region_scope, span, loop_block);
+            self.build_exit_tree(drops, region_scope, span, continue_block);
         }
         match (normal_exit_block, break_block) {
             (Some(block), None) | (None, Some(block)) => block,
@@ -634,30 +635,33 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 .rposition(|breakable_scope| breakable_scope.region_scope == scope)
                 .unwrap_or_else(|| span_bug!(span, "no enclosing breakable scope found"))
         };
-        let (break_index, destination) = match target {
+        let (break_index, destination, dest_scope) = match target {
             BreakableTarget::Return => {
                 let scope = &self.scopes.breakable_scopes[0];
                 if scope.break_destination != Place::return_place() {
                     span_bug!(span, "`return` in item with no return scope");
                 }
-                (0, Some(scope.break_destination))
+                (0, Some(scope.break_destination), scope.destination_scope)
             }
             BreakableTarget::Break(scope) => {
                 let break_index = get_scope_index(scope);
                 let scope = &self.scopes.breakable_scopes[break_index];
-                (break_index, Some(scope.break_destination))
+                (break_index, Some(scope.break_destination), scope.destination_scope)
             }
             BreakableTarget::Continue(scope) => {
                 let break_index = get_scope_index(scope);
-                (break_index, None)
+                (break_index, None, None)
             }
         };
 
         match (destination, value) {
             (Some(destination), Some(value)) => {
                 debug!("stmt_expr Break val block_context.push(SubExpr)");
                 self.block_context.push(BlockFrame::SubExpr);
-                unpack!(block = self.expr_into_dest(destination, block, value));
+                unpack!(block = self.expr_into_dest(destination, dest_scope, block, value));
+                if let Some(scope) = dest_scope {
+                    self.unschedule_drop(scope, destination.as_local().unwrap())
+                };
                 self.block_context.pop();
             }
             (Some(destination), None) => {
@@ -1014,17 +1018,56 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
         }
 
-        span_bug!(span, "region scope {:?} not in scope to drop {:?}", region_scope, local);
+        span_bug!(
+            span,
+            "region scope {:?} not in scope to drop {:?}\n{:#?}",
+            region_scope,
+            local,
+            self.scopes.scopes
+        );
+    }
+
+    /// Unschedule a drop. Used for `break`, `return` and `match` expressions,
+    /// where `record_operands_moved` is not powerful enough.
+    ///
+    /// The given local is expected to have a value drop scheduled in the given
+    /// scope and for that drop to be the most recent thing scheduled in that
+    /// scope.
+    pub(crate) fn unschedule_drop(&mut self, region_scope: region::Scope, local: Local) {
+        if !self.local_decls[local].ty.needs_drop(self.tcx, self.param_env) {
+            return;
+        }
+        for scope in self.scopes.scopes.iter_mut().rev() {
+            scope.invalidate_cache();
+
+            if scope.region_scope == region_scope {
+                let drop = scope.drops.pop();
+
+                match drop {
+                    Some(DropData { local: removed_local, kind: DropKind::Value, .. })
+                        if removed_local == local =>
+                    {
+                        return;
+                    }
+                    _ => bug!(
+                        "found wrong drop, expected value drop of {:?}, found {:?}",
+                        local,
+                        drop,
+                    ),
+                }
+            }
+        }
+
+        bug!("region scope {:?} not in scope to unschedule drop of {:?}", region_scope, local);
     }
 
-    /// Indicates that the "local operand" stored in `local` is
+    /// Indicates that the "local operands" stored in `local` are
     /// *moved* at some point during execution (see `local_scope` for
     /// more information about what a "local operand" is -- in short,
     /// it's an intermediate operand created as part of preparing some
     /// MIR instruction). We use this information to suppress
-    /// redundant drops on the non-unwind paths. This results in less
-    /// MIR, but also avoids spurious borrow check errors
-    /// (c.f. #64391).
+    /// redundant drops. This results in less MIR, but also avoids spurious
+    /// borrow check errors (c.f. #64391).
     ///
     /// Example: when compiling the call to `foo` here:
     ///
@@ -1053,27 +1096,23 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// spurious borrow-check errors -- the problem, ironically, is
     /// not the `DROP(_X)` itself, but the (spurious) unwind pathways
     /// that it creates. See #64391 for an example.
-    pub(crate) fn record_operands_moved(&mut self, operands: &[Spanned<Operand<'tcx>>]) {
+    pub(crate) fn record_operands_moved(&mut self, operands: &[Operand<'tcx>]) {
         let local_scope = self.local_scope();
         let scope = self.scopes.scopes.last_mut().unwrap();
 
         assert_eq!(scope.region_scope, local_scope, "local scope is not the topmost scope!",);
 
         // look for moves of a local variable, like `MOVE(_X)`
-        let locals_moved = operands.iter().flat_map(|operand| match operand.node {
+        let locals_moved = operands.iter().flat_map(|operand| match operand {
             Operand::Copy(_) | Operand::Constant(_) => None,
             Operand::Move(place) => place.as_local(),
         });
 
         for local in locals_moved {
-            // check if we have a Drop for this operand and -- if so
-            // -- add it to the list of moved operands. Note that this
-            // local might not have been an operand created for this
-            // call, it could come from other places too.
-            if scope.drops.iter().any(|drop| drop.local == local && drop.kind == DropKind::Value) {
-                scope.moved_locals.push(local);
-            }
+            // Unschedule drops from the scope.
+            scope.drops.retain(|drop| drop.local != local || drop.kind != DropKind::Value);
         }
+        scope.invalidate_cache();
     }
 
     // Other
@@ -1251,6 +1290,22 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         top_scope.drops.clear();
         top_scope.invalidate_cache();
     }
+
+    /// Unschedules the drop of the return place.
+    ///
+    /// If the return type of a function requires drop, then we schedule it
+    /// in the outermost scope so that it's dropped if there's a panic while
+    /// we drop any local variables. But we don't want to drop it if we
+    /// return normally.
+    pub(crate) fn unschedule_return_place_drop(&mut self) {
+        assert_eq!(self.scopes.scopes.len(), 1);
+        assert!(
+            self.scopes.scopes[0].drops.len() <= 1,
+            "Found too many drops: {:?}",
+            self.scopes.scopes[0].drops
+        );
+        self.scopes.scopes[0].drops.clear();
+    }
 }
 
 /// Builds drops for `pop_scope` and `leave_top_scope`.
@@ -1297,14 +1352,6 @@ fn build_scope_drops<'tcx>(
                 debug_assert_eq!(unwind_drops.drops[unwind_to].data.kind, drop_data.kind);
                 unwind_to = unwind_drops.drops[unwind_to].next;
 
-                // If the operand has been moved, and we are not on an unwind
-                // path, then don't generate the drop. (We only take this into
-                // account for non-unwind paths so as not to disturb the
-                // caching mechanism.)
-                if scope.moved_locals.iter().any(|&o| o == local) {
-                    continue;
-                }
-
                 unwind_drops.add_entry_point(block, unwind_to);
 
                 let next = cfg.start_new_block();
@@ -1339,23 +1386,29 @@ impl<'a, 'tcx: 'a> Builder<'a, 'tcx> {
     /// Build a drop tree for a breakable scope.
     ///
     /// If `continue_block` is `Some`, then the tree is for `continue` inside a
-    /// loop. Otherwise this is for `break` or `return`.
+    /// loop. Otherwise this is for `break` or `return`. The `DropIdx` is the
+    /// next drop in the case that the drop tree unwinds. This is needed
+    /// because the drop of the break destination has already been scheduled
+    /// but it hasn't been initialized on the `continue` paths.
     fn build_exit_tree(
         &mut self,
         mut drops: DropTree,
         else_scope: region::Scope,
         span: Span,
-        continue_block: Option<BasicBlock>,
+        continue_block: Option<(BasicBlock, DropIdx)>,
     ) -> Option<BlockAnd<()>> {
         let mut blocks = IndexVec::from_elem(None, &drops.drops);
-        blocks[ROOT_NODE] = continue_block;
+        blocks[ROOT_NODE] = continue_block.map(|(block, _)| block);
 
         drops.build_mir::<ExitScopes>(&mut self.cfg, &mut blocks);
         let is_coroutine = self.coroutine.is_some();
 
         // Link the exit drop tree to unwind drop tree.
         if drops.drops.iter().any(|drop_node| drop_node.data.kind == DropKind::Value) {
-            let unwind_target = self.diverge_cleanup_target(else_scope, span);
+            let unwind_target = continue_block.map_or_else(
+                || self.diverge_cleanup_target(else_scope, span),
+                |(_, unwind_target)| unwind_target,
+            );
             let mut unwind_indices = IndexVec::from_elem_n(unwind_target, 1);
             for (drop_idx, drop_node) in drops.drops.iter_enumerated().skip(1) {
                 match drop_node.data.kind {

library/alloc/src/collections/btree/map/tests.rs

@@ -2104,6 +2104,7 @@ create_append_test!(test_append_1700, 1700);
 
 #[test]
 #[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+#[cfg_attr(bootstrap, ignore = "test requires compiler fix from current nightly")]
 fn test_append_drop_leak() {
     let a = CrashTestDummy::new(0);
     let b = CrashTestDummy::new(1);
@@ -2118,7 +2119,7 @@ fn test_append_drop_leak() {
 
     catch_unwind(move || left.append(&mut right)).unwrap_err();
     assert_eq!(a.dropped(), 1);
-    assert_eq!(b.dropped(), 1); // should be 2 were it not for Rust issue #47949
+    assert_eq!(b.dropped(), 2);
     assert_eq!(c.dropped(), 2);
 }
 

tests/mir-opt/box_expr.main.ElaborateDrops.diff

@@ -26,62 +26,57 @@
       bb1: {
           StorageLive(_5);
           _5 = ShallowInitBox(move _4, S);
-          (*_5) = S::new() -> [return: bb2, unwind: bb8];
+          (*_5) = S::new() -> [return: bb2, unwind: bb7];
       }
 
       bb2: {
           _1 = move _5;
--         drop(_5) -> [return: bb3, unwind continue];
-+         goto -> bb3;
-      }
-  
-      bb3: {
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
           _7 = move _1;
-          _6 = std::mem::drop::<Box<S>>(move _7) -> [return: bb4, unwind: bb6];
+          _6 = std::mem::drop::<Box<S>>(move _7) -> [return: bb3, unwind: bb5];
       }
 
-      bb4: {
+      bb3: {
           StorageDead(_7);
           StorageDead(_6);
           _0 = const ();
--         drop(_1) -> [return: bb5, unwind continue];
-+         goto -> bb5;
+-         drop(_1) -> [return: bb4, unwind continue];
++         goto -> bb4;
       }
 
-      bb5: {
+      bb4: {
           StorageDead(_1);
           return;
       }
 
+      bb5 (cleanup): {
+-         drop(_7) -> [return: bb6, unwind terminate(cleanup)];
++         goto -> bb6;
+      }
+  
       bb6 (cleanup): {
--         drop(_7) -> [return: bb7, unwind terminate(cleanup)];
-+         goto -> bb7;
+-         drop(_1) -> [return: bb8, unwind terminate(cleanup)];
++         goto -> bb8;
       }
 
       bb7 (cleanup): {
--         drop(_1) -> [return: bb9, unwind terminate(cleanup)];
-+         goto -> bb9;
+-         drop(_5) -> [return: bb8, unwind terminate(cleanup)];
++         goto -> bb10;
       }
 
       bb8 (cleanup): {
--         drop(_5) -> [return: bb9, unwind terminate(cleanup)];
-+         goto -> bb11;
-      }
-  
-      bb9 (cleanup): {
           resume;
 +     }
 + 
-+     bb10 (cleanup): {
++     bb9 (cleanup): {
 +         _8 = &mut _5;
-+         _9 = <Box<S> as Drop>::drop(move _8) -> [return: bb9, unwind terminate(cleanup)];
++         _9 = <Box<S> as Drop>::drop(move _8) -> [return: bb8, unwind terminate(cleanup)];
 +     }
 + 
-+     bb11 (cleanup): {
-+         goto -> bb10;
++     bb10 (cleanup): {
++         goto -> bb9;
       }
   }
 

tests/mir-opt/building/uniform_array_move_out.move_out_by_subslice.built.after.mir

@@ -26,86 +26,66 @@ fn move_out_by_subslice() -> () {
         StorageLive(_2);
         _3 = SizeOf(i32);
         _4 = AlignOf(i32);
-        _5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb14];
+        _5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb9];
     }
 
     bb1: {
         StorageLive(_6);
         _6 = ShallowInitBox(move _5, i32);
         (*_6) = const 1_i32;
         _2 = move _6;
-        drop(_6) -> [return: bb2, unwind: bb13];
-    }
-
-    bb2: {
         StorageDead(_6);
         StorageLive(_7);
         _8 = SizeOf(i32);
         _9 = AlignOf(i32);
-        _10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb3, unwind: bb13];
+        _10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb2, unwind: bb8];
     }
 
-    bb3: {
+    bb2: {
         StorageLive(_11);
         _11 = ShallowInitBox(move _10, i32);
         (*_11) = const 2_i32;
         _7 = move _11;
-        drop(_11) -> [return: bb4, unwind: bb12];
-    }
-
-    bb4: {
         StorageDead(_11);
         _1 = [move _2, move _7];
-        drop(_7) -> [return: bb5, unwind: bb13];
-    }
-
-    bb5: {
         StorageDead(_7);
-        drop(_2) -> [return: bb6, unwind: bb14];
-    }
-
-    bb6: {
         StorageDead(_2);
         FakeRead(ForLet(None), _1);
         PlaceMention(_1);
         StorageLive(_12);
         _12 = move _1[0..2];
         _0 = const ();
-        drop(_12) -> [return: bb9, unwind: bb11];
+        drop(_12) -> [return: bb5, unwind: bb7];
     }
 
-    bb7: {
+    bb3: {
         FakeRead(ForMatchedPlace(None), _1);
         unreachable;
     }
 
-    bb8: {
-        goto -> bb7;
+    bb4: {
+        goto -> bb3;
     }
 
-    bb9: {
+    bb5: {
         StorageDead(_12);
-        drop(_1) -> [return: bb10, unwind: bb14];
+        drop(_1) -> [return: bb6, unwind: bb9];
     }
 
-    bb10: {
+    bb6: {
         StorageDead(_1);
         return;
     }
 
-    bb11 (cleanup): {
-        drop(_1) -> [return: bb14, unwind terminate(cleanup)];
-    }
-
-    bb12 (cleanup): {
-        drop(_7) -> [return: bb13, unwind terminate(cleanup)];
+    bb7 (cleanup): {
+        drop(_1) -> [return: bb9, unwind terminate(cleanup)];
     }
 
-    bb13 (cleanup): {
-        drop(_2) -> [return: bb14, unwind terminate(cleanup)];
+    bb8 (cleanup): {
+        drop(_2) -> [return: bb9, unwind terminate(cleanup)];
     }
 
-    bb14 (cleanup): {
+    bb9 (cleanup): {
         resume;
     }
 }

tests/mir-opt/building/uniform_array_move_out.move_out_from_end.built.after.mir

@@ -26,86 +26,66 @@ fn move_out_from_end() -> () {
         StorageLive(_2);
         _3 = SizeOf(i32);
         _4 = AlignOf(i32);
-        _5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb14];
+        _5 = alloc::alloc::exchange_malloc(move _3, move _4) -> [return: bb1, unwind: bb9];
     }
 
     bb1: {
         StorageLive(_6);
         _6 = ShallowInitBox(move _5, i32);
         (*_6) = const 1_i32;
         _2 = move _6;
-        drop(_6) -> [return: bb2, unwind: bb13];
-    }
-
-    bb2: {
         StorageDead(_6);
         StorageLive(_7);
         _8 = SizeOf(i32);
         _9 = AlignOf(i32);
-        _10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb3, unwind: bb13];
+        _10 = alloc::alloc::exchange_malloc(move _8, move _9) -> [return: bb2, unwind: bb8];
     }
 
-    bb3: {
+    bb2: {
         StorageLive(_11);
         _11 = ShallowInitBox(move _10, i32);
         (*_11) = const 2_i32;
         _7 = move _11;
-        drop(_11) -> [return: bb4, unwind: bb12];
-    }
-
-    bb4: {
         StorageDead(_11);
         _1 = [move _2, move _7];
-        drop(_7) -> [return: bb5, unwind: bb13];
-    }
-
-    bb5: {
         StorageDead(_7);
-        drop(_2) -> [return: bb6, unwind: bb14];
-    }
-
-    bb6: {
         StorageDead(_2);
         FakeRead(ForLet(None), _1);
         PlaceMention(_1);
         StorageLive(_12);
         _12 = move _1[1 of 2];
         _0 = const ();
-        drop(_12) -> [return: bb9, unwind: bb11];
+        drop(_12) -> [return: bb5, unwind: bb7];
     }
 
-    bb7: {
+    bb3: {
         FakeRead(ForMatchedPlace(None), _1);
         unreachable;
     }
 
-    bb8: {
-        goto -> bb7;
+    bb4: {
+        goto -> bb3;
     }
 
-    bb9: {
+    bb5: {
         StorageDead(_12);
-        drop(_1) -> [return: bb10, unwind: bb14];
+        drop(_1) -> [return: bb6, unwind: bb9];
     }
 
-    bb10: {
+    bb6: {
         StorageDead(_1);
         return;
     }
 
-    bb11 (cleanup): {
-        drop(_1) -> [return: bb14, unwind terminate(cleanup)];
-    }
-
-    bb12 (cleanup): {
-        drop(_7) -> [return: bb13, unwind terminate(cleanup)];
+    bb7 (cleanup): {
+        drop(_1) -> [return: bb9, unwind terminate(cleanup)];
     }
 
-    bb13 (cleanup): {
-        drop(_2) -> [return: bb14, unwind terminate(cleanup)];
+    bb8 (cleanup): {
+        drop(_2) -> [return: bb9, unwind terminate(cleanup)];
     }
 
-    bb14 (cleanup): {
+    bb9 (cleanup): {
         resume;
     }
 }

tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff

@@ -29,14 +29,14 @@
 +         StorageLive(_4);
 +         StorageLive(_3);
 +         _3 = &_2;
-+         _4 = <fn() -> ! {sleep} as Fn<()>>::call(move _3, const ()) -> [return: bb1, unwind: bb5];
++         _4 = <fn() -> ! {sleep} as Fn<()>>::call(move _3, const ()) -> [return: bb1, unwind: bb6];
 +     }
 + 
 +     bb1: {
 +         StorageDead(_3);
 +         StorageLive(_5);
 +         _5 = &_2;
-+         _6 = <fn() -> ! {sleep} as Fn<()>>::call(move _5, const ()) -> [return: bb2, unwind: bb4];
++         _6 = <fn() -> ! {sleep} as Fn<()>>::call(move _5, const ()) -> [return: bb2, unwind: bb5];
 +     }
 + 
 +     bb2: {
@@ -46,22 +46,26 @@
 +         _1 = (move _7, _6);
 +         StorageDead(_7);
 +         StorageDead(_4);
-+         drop(_2) -> [return: bb3, unwind continue];
++         drop(_2) -> [return: bb3, unwind: bb4];
 +     }
 + 
 +     bb3: {
 +         unreachable;
 +     }
 + 
 +     bb4 (cleanup): {
-+         drop(_4) -> [return: bb5, unwind terminate(cleanup)];
++         drop(_1) -> [return: bb7, unwind terminate(cleanup)];
 +     }
 + 
 +     bb5 (cleanup): {
-+         drop(_2) -> [return: bb6, unwind terminate(cleanup)];
++         drop(_4) -> [return: bb6, unwind terminate(cleanup)];
 +     }
 + 
 +     bb6 (cleanup): {
++         drop(_2) -> [return: bb7, unwind terminate(cleanup)];
++     }
++ 
++     bb7 (cleanup): {
 +         resume;
       }
   }

tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir

@@ -29,7 +29,7 @@ fn test() -> Option<Box<u32>> {
         StorageLive(_1);
         _2 = SizeOf(u32);
         _3 = AlignOf(u32);
-        _4 = alloc::alloc::exchange_malloc(move _2, move _3) -> [return: bb1, unwind: bb13];
+        _4 = alloc::alloc::exchange_malloc(move _2, move _3) -> [return: bb1, unwind: bb11];
     }
 
     bb1: {
@@ -38,7 +38,7 @@ fn test() -> Option<Box<u32>> {
         StorageLive(_6);
         StorageLive(_7);
         _7 = Option::<u32>::None;
-        _6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb12];
+        _6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb10];
     }
 
     bb2: {
@@ -58,55 +58,47 @@ fn test() -> Option<Box<u32>> {
         (*_5) = _12;
         StorageDead(_12);
         _1 = move _5;
-        drop(_5) -> [return: bb7, unwind: bb11];
+        StorageDead(_5);
+        _0 = Option::<Box<u32>>::Some(move _1);
+        StorageDead(_1);
+        StorageDead(_6);
+        goto -> bb8;
     }
 
     bb5: {
         StorageLive(_9);
         _9 = ((_6 as Break).0: std::option::Option<std::convert::Infallible>);
         StorageLive(_11);
         _11 = _9;
-        _0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12];
+        _0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb10];
     }
 
     bb6: {
         StorageDead(_11);
         StorageDead(_9);
-        drop(_5) -> [return: bb9, unwind: bb13];
+        drop(_5) -> [return: bb7, unwind: bb9];
     }
 
     bb7: {
-        StorageDead(_5);
-        _0 = Option::<Box<u32>>::Some(move _1);
-        drop(_1) -> [return: bb8, unwind: bb13];
-    }
-
-    bb8: {
-        StorageDead(_1);
-        StorageDead(_6);
-        goto -> bb10;
-    }
-
-    bb9: {
         StorageDead(_5);
         StorageDead(_1);
         StorageDead(_6);
-        goto -> bb10;
+        goto -> bb8;
     }
 
-    bb10: {
+    bb8: {
         return;
     }
 
-    bb11 (cleanup): {
-        drop(_1) -> [return: bb13, unwind terminate(cleanup)];
+    bb9 (cleanup): {
+        drop(_0) -> [return: bb11, unwind terminate(cleanup)];
     }
 
-    bb12 (cleanup): {
-        drop(_5) -> [return: bb13, unwind terminate(cleanup)];
+    bb10 (cleanup): {
+        drop(_5) -> [return: bb11, unwind terminate(cleanup)];
     }
 
-    bb13 (cleanup): {
+    bb11 (cleanup): {
         resume;
     }
 }

tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir

@@ -38,7 +38,7 @@ fn test() -> Option<Box<u32>> {
         StorageLive(_6);
         StorageLive(_7);
         _7 = Option::<u32>::None;
-        _6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb12];
+        _6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb10];
     }
 
     bb2: {
@@ -58,55 +58,47 @@ fn test() -> Option<Box<u32>> {
         (*_5) = _12;
         StorageDead(_12);
         _1 = move _5;
-        drop(_5) -> [return: bb7, unwind: bb11];
+        StorageDead(_5);
+        _0 = Option::<Box<u32>>::Some(move _1);
+        StorageDead(_1);
+        StorageDead(_6);
+        goto -> bb8;
     }
 
     bb5: {
         StorageLive(_9);
         _9 = ((_6 as Break).0: std::option::Option<std::convert::Infallible>);
         StorageLive(_11);
         _11 = _9;
-        _0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12];
+        _0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb10];
     }
 
     bb6: {
         StorageDead(_11);
         StorageDead(_9);
-        drop(_5) -> [return: bb9, unwind continue];
+        drop(_5) -> [return: bb7, unwind: bb9];
     }
 
     bb7: {
-        StorageDead(_5);
-        _0 = Option::<Box<u32>>::Some(move _1);
-        drop(_1) -> [return: bb8, unwind continue];
-    }
-
-    bb8: {
-        StorageDead(_1);
-        StorageDead(_6);
-        goto -> bb10;
-    }
-
-    bb9: {
         StorageDead(_5);
         StorageDead(_1);
         StorageDead(_6);
-        goto -> bb10;
+        goto -> bb8;
     }
 
-    bb10: {
+    bb8: {
         return;
     }
 
-    bb11 (cleanup): {
-        drop(_1) -> [return: bb13, unwind terminate(cleanup)];
+    bb9 (cleanup): {
+        drop(_0) -> [return: bb11, unwind terminate(cleanup)];
     }
 
-    bb12 (cleanup): {
-        drop(_5) -> [return: bb13, unwind terminate(cleanup)];
+    bb10 (cleanup): {
+        drop(_5) -> [return: bb11, unwind terminate(cleanup)];
     }
 
-    bb13 (cleanup): {
+    bb11 (cleanup): {
         resume;
     }
 }

tests/mir-opt/issue_91633.foo.built.after.mir

@@ -19,12 +19,12 @@ fn foo(_1: Box<[T]>) -> T {
         _4 = const 0_usize;
         _5 = Len((*_1));
         _6 = Lt(_4, _5);
-        assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind: bb5];
+        assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind: bb7];
     }
 
     bb1: {
         _3 = &(*_1)[_4];
-        _2 = <T as Clone>::clone(move _3) -> [return: bb2, unwind: bb5];
+        _2 = <T as Clone>::clone(move _3) -> [return: bb2, unwind: bb7];
     }
 
     bb2: {
@@ -49,6 +49,14 @@ fn foo(_1: Box<[T]>) -> T {
     }
 
     bb6 (cleanup): {
+        drop(_0) -> [return: bb8, unwind terminate(cleanup)];
+    }
+
+    bb7 (cleanup): {
+        drop(_1) -> [return: bb8, unwind terminate(cleanup)];
+    }
+
+    bb8 (cleanup): {
         resume;
     }
 }

tests/mir-opt/sroa/structs.dropping.ScalarReplacementOfAggregates.diff

@@ -23,22 +23,22 @@
           StorageDead(_4);
           StorageDead(_3);
           _1 = move (_2.1: Tag);
-          drop(_1) -> [return: bb1, unwind unreachable];
+          drop(_1) -> [return: bb3, unwind unreachable];
       }
 
       bb1: {
-          drop((_2.0: Tag)) -> [return: bb3, unwind unreachable];
-      }
-  
-      bb2: {
           StorageDead(_2);
           StorageDead(_1);
           _0 = const ();
           return;
       }
 
+      bb2: {
+          drop((_2.2: Tag)) -> [return: bb1, unwind unreachable];
+      }
+  
       bb3: {
-          drop((_2.2: Tag)) -> [return: bb2, unwind unreachable];
+          drop((_2.0: Tag)) -> [return: bb2, unwind unreachable];
       }
   }
 

tests/ui/deriving/deriving-with-helper.rs

@@ -29,6 +29,9 @@ mod default {
 #[lang = "sized"]
 trait Sized {}
 
+#[lang = "copy"]
+trait Copy: Sized {}
+
 #[derive(Default)]
 enum S {
     #[default] // OK

tests/ui/drop/dynamic-drop-async.rs

@@ -43,6 +43,7 @@ impl<T: Unpin> Future for Defer<T> {
 /// The `failing_op`-th operation will panic.
 struct Allocator {
     data: RefCell<Vec<bool>>,
+    name: &'static str,
     failing_op: usize,
     cur_ops: Cell<usize>,
 }
@@ -54,23 +55,28 @@ impl Drop for Allocator {
     fn drop(&mut self) {
         let data = self.data.borrow();
         if data.iter().any(|d| *d) {
-            panic!("missing free: {:?}", data);
+            panic!("missing free in {:?}: {:?}", self.name, data);
         }
     }
 }
 
 impl Allocator {
-    fn new(failing_op: usize) -> Self {
-        Allocator { failing_op, cur_ops: Cell::new(0), data: RefCell::new(vec![]) }
+    fn new(failing_op: usize, name: &'static str) -> Self {
+        Allocator {
+            failing_op,
+            name,
+            cur_ops: Cell::new(0),
+            data: RefCell::new(vec![]),
+        }
     }
-    fn alloc(&self) -> impl Future<Output = Ptr<'_>> + '_ {
+    fn alloc(self: &Rc<Allocator>) -> impl Future<Output = Ptr> + 'static {
         self.fallible_operation();
 
         let mut data = self.data.borrow_mut();
 
         let addr = data.len();
         data.push(true);
-        Defer { ready: false, value: Some(Ptr(addr, self)) }
+        Defer { ready: false, value: Some(Ptr(addr, self.clone())) }
     }
     fn fallible_operation(&self) {
         self.cur_ops.set(self.cur_ops.get() + 1);
@@ -83,11 +89,11 @@ impl Allocator {
 
 // Type that tracks whether it was dropped and can panic when it's created or
 // destroyed.
-struct Ptr<'a>(usize, &'a Allocator);
-impl<'a> Drop for Ptr<'a> {
+struct Ptr(usize, Rc<Allocator>);
+impl Drop for Ptr {
     fn drop(&mut self) {
         match self.1.data.borrow_mut()[self.0] {
-            false => panic!("double free at index {:?}", self.0),
+            false => panic!("double free in {:?} at index {:?}", self.1.name, self.0),
             ref mut d => *d = false,
         }
 
@@ -111,7 +117,7 @@ async fn dynamic_drop(a: Rc<Allocator>, c: bool) {
     };
 }
 
-struct TwoPtrs<'a>(Ptr<'a>, Ptr<'a>);
+struct TwoPtrs(Ptr, Ptr);
 async fn struct_dynamic_drop(a: Rc<Allocator>, c0: bool, c1: bool, c: bool) {
     for i in 0..2 {
         let x;
@@ -232,21 +238,62 @@ async fn move_ref_pattern(a: Rc<Allocator>) {
     a.alloc().await;
 }
 
-fn run_test<F, G>(cx: &mut Context<'_>, ref f: F)
+async fn panic_after_return(a: Rc<Allocator>, c: bool) -> (Ptr,) {
+    a.alloc().await;
+    let p = a.alloc().await;
+    if c {
+        a.alloc().await;
+        let q = a.alloc().await;
+        // We use a return type that isn't used anywhere else to make sure that
+        // the return place doesn't incorrectly end up in the generator state.
+        return (a.alloc().await,);
+    }
+    (a.alloc().await,)
+}
+
+
+async fn panic_after_init_by_loop(a: Rc<Allocator>) {
+    a.alloc().await;
+    let p = a.alloc().await;
+    let q = loop {
+        a.alloc().await;
+        let r = a.alloc().await;
+        break a.alloc().await;
+    };
+}
+
+async fn panic_after_init_by_match_with_bindings_and_guard(a: Rc<Allocator>, b: bool) {
+    a.alloc().await;
+    let p = a.alloc().await;
+    let q = match a.alloc().await {
+        ref _x if b => {
+            a.alloc().await;
+            let r = a.alloc().await;
+            a.alloc().await
+        }
+        _x => {
+            a.alloc().await;
+            let r = a.alloc().await;
+            a.alloc().await
+        },
+    };
+}
+
+fn run_test<F, G, O>(cx: &mut Context<'_>, ref f: F, name: &'static str)
 where
     F: Fn(Rc<Allocator>) -> G,
-    G: Future<Output = ()>,
+    G: Future<Output = O>,
 {
     for polls in 0.. {
         // Run without any panics to find which operations happen after the
         // penultimate `poll`.
-        let first_alloc = Rc::new(Allocator::new(usize::MAX));
+        let first_alloc = Rc::new(Allocator::new(usize::MAX, name));
         let mut fut = Box::pin(f(first_alloc.clone()));
         let mut ops_before_last_poll = 0;
         let mut completed = false;
         for _ in 0..polls {
             ops_before_last_poll = first_alloc.cur_ops.get();
-            if let Poll::Ready(()) = fut.as_mut().poll(cx) {
+            if let Poll::Ready(_) = fut.as_mut().poll(cx) {
                 completed = true;
             }
         }
@@ -255,7 +302,7 @@ where
         // Start at `ops_before_last_poll` so that we will always be able to
         // `poll` the expected number of times.
         for failing_op in ops_before_last_poll..first_alloc.cur_ops.get() {
-            let alloc = Rc::new(Allocator::new(failing_op + 1));
+            let alloc = Rc::new(Allocator::new(failing_op + 1, name));
             let f = &f;
             let cx = &mut *cx;
             let result = panic::catch_unwind(panic::AssertUnwindSafe(move || {
@@ -285,48 +332,58 @@ fn clone_waker(data: *const ()) -> RawWaker {
     RawWaker::new(data, &RawWakerVTable::new(clone_waker, drop, drop, drop))
 }
 
+macro_rules! run_test {
+    ($ctxt:expr, $e:expr) => { run_test($ctxt, $e, stringify!($e)); };
+}
+
 fn main() {
     let waker = unsafe { Waker::from_raw(clone_waker(ptr::null())) };
     let context = &mut Context::from_waker(&waker);
 
-    run_test(context, |a| dynamic_init(a, false));
-    run_test(context, |a| dynamic_init(a, true));
-    run_test(context, |a| dynamic_drop(a, false));
-    run_test(context, |a| dynamic_drop(a, true));
-
-    run_test(context, |a| assignment(a, false, false));
-    run_test(context, |a| assignment(a, false, true));
-    run_test(context, |a| assignment(a, true, false));
-    run_test(context, |a| assignment(a, true, true));
-
-    run_test(context, |a| array_simple(a));
-    run_test(context, |a| vec_simple(a));
-    run_test(context, |a| vec_unreachable(a));
-
-    run_test(context, |a| struct_dynamic_drop(a, false, false, false));
-    run_test(context, |a| struct_dynamic_drop(a, false, false, true));
-    run_test(context, |a| struct_dynamic_drop(a, false, true, false));
-    run_test(context, |a| struct_dynamic_drop(a, false, true, true));
-    run_test(context, |a| struct_dynamic_drop(a, true, false, false));
-    run_test(context, |a| struct_dynamic_drop(a, true, false, true));
-    run_test(context, |a| struct_dynamic_drop(a, true, true, false));
-    run_test(context, |a| struct_dynamic_drop(a, true, true, true));
-
-    run_test(context, |a| field_assignment(a, false));
-    run_test(context, |a| field_assignment(a, true));
-
-    run_test(context, |a| mixed_drop_and_nondrop(a));
-
-    run_test(context, |a| slice_pattern_one_of(a, 0));
-    run_test(context, |a| slice_pattern_one_of(a, 1));
-    run_test(context, |a| slice_pattern_one_of(a, 2));
-    run_test(context, |a| slice_pattern_one_of(a, 3));
-
-    run_test(context, |a| subslice_pattern_from_end_with_drop(a, true, true));
-    run_test(context, |a| subslice_pattern_from_end_with_drop(a, true, false));
-    run_test(context, |a| subslice_pattern_from_end_with_drop(a, false, true));
-    run_test(context, |a| subslice_pattern_from_end_with_drop(a, false, false));
-    run_test(context, |a| subslice_pattern_reassign(a));
-
-    run_test(context, |a| move_ref_pattern(a));
+    run_test!(context, |a| dynamic_init(a, false));
+    run_test!(context, |a| dynamic_init(a, true));
+    run_test!(context, |a| dynamic_drop(a, false));
+    run_test!(context, |a| dynamic_drop(a, true));
+
+    run_test!(context, |a| assignment(a, false, false));
+    run_test!(context, |a| assignment(a, false, true));
+    run_test!(context, |a| assignment(a, true, false));
+    run_test!(context, |a| assignment(a, true, true));
+
+    run_test!(context, |a| array_simple(a));
+    run_test!(context, |a| vec_simple(a));
+    run_test!(context, |a| vec_unreachable(a));
+
+    run_test!(context, |a| struct_dynamic_drop(a, false, false, false));
+    run_test!(context, |a| struct_dynamic_drop(a, false, false, true));
+    run_test!(context, |a| struct_dynamic_drop(a, false, true, false));
+    run_test!(context, |a| struct_dynamic_drop(a, false, true, true));
+    run_test!(context, |a| struct_dynamic_drop(a, true, false, false));
+    run_test!(context, |a| struct_dynamic_drop(a, true, false, true));
+    run_test!(context, |a| struct_dynamic_drop(a, true, true, false));
+    run_test!(context, |a| struct_dynamic_drop(a, true, true, true));
+
+    run_test!(context, |a| field_assignment(a, false));
+    run_test!(context, |a| field_assignment(a, true));
+
+    run_test!(context, |a| mixed_drop_and_nondrop(a));
+
+    run_test!(context, |a| slice_pattern_one_of(a, 0));
+    run_test!(context, |a| slice_pattern_one_of(a, 1));
+    run_test!(context, |a| slice_pattern_one_of(a, 2));
+    run_test!(context, |a| slice_pattern_one_of(a, 3));
+
+    run_test!(context, |a| subslice_pattern_from_end_with_drop(a, true, true));
+    run_test!(context, |a| subslice_pattern_from_end_with_drop(a, true, false));
+    run_test!(context, |a| subslice_pattern_from_end_with_drop(a, false, true));
+    run_test!(context, |a| subslice_pattern_from_end_with_drop(a, false, false));
+    run_test!(context, |a| subslice_pattern_reassign(a));
+
+    run_test!(context, |a| move_ref_pattern(a));
+
+    run_test!(context, |a| panic_after_return(a, false));
+    run_test!(context, |a| panic_after_return(a, true));
+    run_test!(context, |a| panic_after_init_by_loop(a));
+    run_test!(context, |a| panic_after_init_by_match_with_bindings_and_guard(a, false));
+    run_test!(context, |a| panic_after_init_by_match_with_bindings_and_guard(a, true));
 }

tests/ui/drop/dynamic-drop.rs

@@ -14,8 +14,6 @@ pub fn func<V, F: Fn(&mut V)>(f: F) -> A<impl X> {
     //~| ERROR implementation of `FnOnce` is not general enough
     //~| ERROR implementation of `Fn` is not general enough
     //~| ERROR implementation of `FnOnce` is not general enough
-    //~| ERROR higher-ranked subtype error
-    //~| ERROR higher-ranked subtype error
 }
 
 trait X {}

tests/ui/nll/ice-106874.rs

@@ -72,19 +72,5 @@ LL |     A(B(C::new(D::new(move |st| f(st)))))
    = note: closure with signature `fn(&'2 mut V)` must implement `FnOnce<(&'1 mut V,)>`, for any lifetime `'1`...
    = note: ...but it actually implements `FnOnce<(&'2 mut V,)>`, for some specific lifetime `'2`
 
-error: higher-ranked subtype error
-  --> $DIR/ice-106874.rs:8:41
-   |
-LL |     A(B(C::new(D::new(move |st| f(st)))))
-   |                                         ^
-
-error: higher-ranked subtype error
-  --> $DIR/ice-106874.rs:8:41
-   |
-LL |     A(B(C::new(D::new(move |st| f(st)))))
-   |                                         ^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 10 previous errors
+error: aborting due to 8 previous errors