diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 240bd20053b15..eee440a6dfed8 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -659,7 +659,14 @@ impl<'a, 'tcx> ResultsVisitor<'a, 'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<
TerminatorKind::SwitchInt { discr, targets: _ } => {
self.consume_operand(loc, (discr, span), state);
}
- TerminatorKind::Drop { place, target: _, unwind: _, replace } => {
+ TerminatorKind::Drop {
+ place,
+ target: _,
+ unwind: _,
+ replace,
+ drop: _,
+ async_fut: _,
+ } => {
debug!(
"visit_terminator_drop \
loc: {:?} term: {:?} place: {:?} span: {:?}",
diff --git a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
index 0d1d8642bcacc..99dd0b2dd4664 100644
--- a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
@@ -101,7 +101,14 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'a, 'tcx> {
TerminatorKind::SwitchInt { discr, targets: _ } => {
self.consume_operand(location, discr);
}
- TerminatorKind::Drop { place: drop_place, target: _, unwind: _, replace } => {
+ TerminatorKind::Drop {
+ place: drop_place,
+ target: _,
+ unwind: _,
+ replace,
+ drop: _,
+ async_fut: _,
+ } => {
let write_kind =
if *replace { WriteKind::Replace } else { WriteKind::StorageDeadOrDrop };
self.access_place(
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index f6144a25938ce..b801cfea24a2b 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -2086,8 +2086,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
TerminatorKind::Unreachable => {}
- TerminatorKind::Drop { target, unwind, .. }
- | TerminatorKind::Assert { target, unwind, .. } => {
+ TerminatorKind::Drop { target, unwind, drop, .. } => {
+ self.assert_iscleanup(block_data, target, is_cleanup);
+ self.assert_iscleanup_unwind(block_data, unwind, is_cleanup);
+ if let Some(drop) = drop {
+ self.assert_iscleanup(block_data, drop, is_cleanup);
+ }
+ }
+ TerminatorKind::Assert { target, unwind, .. } => {
self.assert_iscleanup(block_data, target, is_cleanup);
self.assert_iscleanup_unwind(block_data, unwind, is_cleanup);
}
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index adaa754491e56..e9c7186b03c9f 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -565,7 +565,11 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
| TerminatorKind::CoroutineDrop => {
bug!("shouldn't exist at codegen {:?}", bb_data.terminator());
}
- TerminatorKind::Drop { place, target, unwind: _, replace: _ } => {
+ TerminatorKind::Drop { place, target, unwind: _, replace: _, drop, async_fut } => {
+ assert!(
+ async_fut.is_none() && drop.is_none(),
+ "Async Drop must be expanded or reset to sync before codegen"
+ );
let drop_place = codegen_place(fx, *place);
crate::abi::codegen_drop(fx, source_info, drop_place, *target);
}
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index d184ce3d61dea..135d5e44703fd 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -1386,8 +1386,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
MergingSucc::False
}
- mir::TerminatorKind::Drop { place, target, unwind, replace: _ } => self
- .codegen_drop_terminator(
+ mir::TerminatorKind::Drop { place, target, unwind, replace: _, drop, async_fut } => {
+ assert!(
+ async_fut.is_none() && drop.is_none(),
+ "Async Drop must be expanded or reset to sync before codegen"
+ );
+ self.codegen_drop_terminator(
helper,
bx,
&terminator.source_info,
@@ -1395,7 +1399,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
target,
unwind,
mergeable_succ(),
- ),
+ )
+ }
mir::TerminatorKind::Assert { ref cond, expected, ref msg, target, unwind } => self
.codegen_assert_terminator(
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 61a7ec13511c2..7c7daed525b2d 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -502,6 +502,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
RemainderByZero(op) => RemainderByZero(eval_to_int(op)?),
ResumedAfterReturn(coroutine_kind) => ResumedAfterReturn(*coroutine_kind),
ResumedAfterPanic(coroutine_kind) => ResumedAfterPanic(*coroutine_kind),
+ ResumedAfterDrop(coroutine_kind) => ResumedAfterDrop(*coroutine_kind),
MisalignedPointerDereference { required, found } => MisalignedPointerDereference {
required: eval_to_int(required)?,
found: eval_to_int(found)?,
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index ddf2d65914f6c..363ceee1970ee 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -539,7 +539,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
}
}
- Drop { place, target, unwind, replace: _ } => {
+ Drop { place, target, unwind, replace: _, drop, async_fut } => {
+ assert!(
+ async_fut.is_none() && drop.is_none(),
+ "Async Drop must be expanded or reset to sync in runtime MIR"
+ );
let place = self.eval_place(place)?;
let instance = Instance::resolve_drop_in_place(*self.tcx, place.layout.ty);
if let ty::InstanceKind::DropGlue(_, None) = instance.def {
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 90fab01ba2d45..6665fdce6ec99 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -318,6 +318,10 @@ language_item_table! {
PanicAsyncGenFnResumedPanic, sym::panic_const_async_gen_fn_resumed_panic, panic_const_async_gen_fn_resumed_panic, Target::Fn, GenericRequirement::None;
PanicGenFnNonePanic, sym::panic_const_gen_fn_none_panic, panic_const_gen_fn_none_panic, Target::Fn, GenericRequirement::None;
PanicNullPointerDereference, sym::panic_null_pointer_dereference, panic_null_pointer_dereference, Target::Fn, GenericRequirement::None;
+ PanicCoroutineResumedDrop, sym::panic_const_coroutine_resumed_drop, panic_const_coroutine_resumed_drop, Target::Fn, GenericRequirement::None;
+ PanicAsyncFnResumedDrop, sym::panic_const_async_fn_resumed_drop, panic_const_async_fn_resumed_drop, Target::Fn, GenericRequirement::None;
+ PanicAsyncGenFnResumedDrop, sym::panic_const_async_gen_fn_resumed_drop, panic_const_async_gen_fn_resumed_drop, Target::Fn, GenericRequirement::None;
+ PanicGenFnNoneDrop, sym::panic_const_gen_fn_none_drop, panic_const_gen_fn_none_drop, Target::Fn, GenericRequirement::None;
/// libstd panic entry point. Necessary for const eval to be able to catch it
BeginPanic, sym::begin_panic, begin_panic_fn, Target::Fn, GenericRequirement::None;
diff --git a/compiler/rustc_middle/messages.ftl b/compiler/rustc_middle/messages.ftl
index 0b3c0be1a4e1a..3d27e587b6cb4 100644
--- a/compiler/rustc_middle/messages.ftl
+++ b/compiler/rustc_middle/messages.ftl
@@ -1,7 +1,11 @@
+middle_assert_async_resume_after_drop = `async fn` resumed after async drop
+
middle_assert_async_resume_after_panic = `async fn` resumed after panicking
middle_assert_async_resume_after_return = `async fn` resumed after completion
+middle_assert_coroutine_resume_after_drop = coroutine resumed after async drop
+
middle_assert_coroutine_resume_after_panic = coroutine resumed after panicking
middle_assert_coroutine_resume_after_return = coroutine resumed after completion
@@ -9,6 +13,8 @@ middle_assert_coroutine_resume_after_return = coroutine resumed after completion
middle_assert_divide_by_zero =
attempt to divide `{$val}` by zero
+middle_assert_gen_resume_after_drop = `gen` fn or block cannot be further iterated on after it async dropped
+
middle_assert_gen_resume_after_panic = `gen` fn or block cannot be further iterated on after it panicked
middle_assert_misaligned_ptr_deref =
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 5a038b27337cf..b3a6794c9b666 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1050,7 +1050,13 @@ impl<'tcx> TerminatorKind<'tcx> {
Call { target: None, unwind: _, .. } => vec![],
Yield { drop: Some(_), .. } => vec!["resume".into(), "drop".into()],
Yield { drop: None, .. } => vec!["resume".into()],
- Drop { unwind: UnwindAction::Cleanup(_), .. } => vec!["return".into(), "unwind".into()],
+ Drop { unwind: UnwindAction::Cleanup(_), drop: Some(_), .. } => {
+ vec!["return".into(), "unwind".into(), "drop".into()]
+ }
+ Drop { unwind: UnwindAction::Cleanup(_), drop: None, .. } => {
+ vec!["return".into(), "unwind".into()]
+ }
+ Drop { unwind: _, drop: Some(_), .. } => vec!["return".into(), "drop".into()],
Drop { unwind: _, .. } => vec!["return".into()],
Assert { unwind: UnwindAction::Cleanup(_), .. } => {
vec!["success".into(), "unwind".into()]
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index 707c8d04d557f..71ba2917b9b6a 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -77,6 +77,8 @@ pub enum MirPhase {
/// exception is fields of packed structs. In analysis MIR, `Drop(P)` for a `P` that might be
/// misaligned for this reason implicitly moves `P` to a temporary before dropping. Runtime
/// MIR has no such rules, and dropping a misaligned place is simply UB.
+ /// - Async drops: after drop elaboration some drops may become async (`drop`, `async_fut` fields).
+ /// StateTransform pass will expand those async drops or reset to sync.
/// - Unwinding: in analysis MIR, unwinding from a function which may not unwind aborts. In
/// runtime MIR, this is UB.
/// - Retags: If `-Zmir-emit-retag` is enabled, analysis MIR has "implicit" retags in the same
@@ -766,7 +768,34 @@ pub enum TerminatorKind<'tcx> {
/// The `replace` flag indicates whether this terminator was created as part of an assignment.
/// This should only be used for diagnostic purposes, and does not have any operational
/// meaning.
- Drop { place: Place<'tcx>, target: BasicBlock, unwind: UnwindAction, replace: bool },
+ ///
+ /// Async drop processing:
+ /// In compiler/rustc_mir_build/src/build/scope.rs we detect possible async drop:
+ /// drop of object with `needs_async_drop`.
+ /// Async drop later, in StateTransform pass, may be expanded into additional yield-point
+ /// for poll-loop of async drop future.
+ /// So we need prepared 'drop' target block in the similar way as for `Yield` terminator
+ /// (see `drops.build_mir::<CoroutineDrop>` in scopes.rs).
+ /// In compiler/rustc_mir_transform/src/elaborate_drops.rs for object implementing `AsyncDrop` trait
+ /// we need to prepare async drop feature - resolve `AsyncDrop::drop` and codegen call.
+ /// `async_fut` is set to the corresponding local.
+ /// For coroutine drop we don't need this logic because coroutine drop works with the same
+ /// layout object as coroutine itself. So `async_fut` will be `None` for coroutine drop.
+ /// Both `drop` and `async_fut` fields are only used in compiler/rustc_mir_transform/src/coroutine.rs,
+ /// StateTransform pass. In `expand_async_drops` async drops are expanded
+ /// into one or two yield points with poll ready/pending switch.
+ /// When a coroutine has any internal async drop, the coroutine drop function will be async
+ /// (generated by `create_coroutine_drop_shim_async`, not `create_coroutine_drop_shim`).
+ Drop {
+ place: Place<'tcx>,
+ target: BasicBlock,
+ unwind: UnwindAction,
+ replace: bool,
+ /// Cleanup to be done if the coroutine is dropped at this suspend point (for async drop).
+ drop: Option<BasicBlock>,
+ /// Prepared async future local (for async drop)
+ async_fut: Option<Local>,
+ },
/// Roughly speaking, evaluates the `func` operand and the arguments, and starts execution of
/// the referred to function. The operand types must match the argument types of the function.
@@ -1037,6 +1066,7 @@ pub enum AssertKind<O> {
RemainderByZero(O),
ResumedAfterReturn(CoroutineKind),
ResumedAfterPanic(CoroutineKind),
+ ResumedAfterDrop(CoroutineKind),
MisalignedPointerDereference { required: O, found: O },
NullPointerDereference,
}
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index b2c51ad88645c..ca9438b1ed64e 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -208,6 +208,16 @@ impl<O> AssertKind<O> {
LangItem::PanicGenFnNonePanic
}
NullPointerDereference => LangItem::PanicNullPointerDereference,
+ ResumedAfterDrop(CoroutineKind::Coroutine(_)) => LangItem::PanicCoroutineResumedDrop,
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
+ LangItem::PanicAsyncFnResumedDrop
+ }
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _)) => {
+ LangItem::PanicAsyncGenFnResumedDrop
+ }
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Gen, _)) => {
+ LangItem::PanicGenFnNoneDrop
+ }
BoundsCheck { .. } | MisalignedPointerDereference { .. } => {
bug!("Unexpected AssertKind")
@@ -298,6 +308,18 @@ impl<O> AssertKind<O> {
ResumedAfterPanic(CoroutineKind::Desugared(CoroutineDesugaring::Gen, _)) => {
write!(f, "\"`gen fn` should just keep returning `None` after panicking\"")
}
+ ResumedAfterDrop(CoroutineKind::Coroutine(_)) => {
+ write!(f, "\"coroutine resumed after async drop\"")
+ }
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
+ write!(f, "\"`async fn` resumed after async drop\"")
+ }
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _)) => {
+ write!(f, "\"`async gen fn` resumed after async drop\"")
+ }
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Gen, _)) => {
+ write!(f, "\"`gen fn` resumed after drop\"")
+ }
}
}
@@ -345,6 +367,19 @@ impl<O> AssertKind<O> {
middle_assert_coroutine_resume_after_panic
}
NullPointerDereference => middle_assert_null_ptr_deref,
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
+ middle_assert_async_resume_after_drop
+ }
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _)) => {
+ todo!()
+ }
+ ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Gen, _)) => {
+ middle_assert_gen_resume_after_drop
+ }
+ ResumedAfterDrop(CoroutineKind::Coroutine(_)) => {
+ middle_assert_coroutine_resume_after_drop
+ }
+
MisalignedPointerDereference { .. } => middle_assert_misaligned_ptr_deref,
}
}
@@ -377,7 +412,10 @@ impl<O> AssertKind<O> {
add!("left", format!("{left:#?}"));
add!("right", format!("{right:#?}"));
}
- ResumedAfterReturn(_) | ResumedAfterPanic(_) | NullPointerDereference => {}
+ ResumedAfterReturn(_)
+ | ResumedAfterPanic(_)
+ | NullPointerDereference
+ | ResumedAfterDrop(_) => {}
MisalignedPointerDereference { required, found } => {
add!("required", format!("{required:#?}"));
add!("found", format!("{found:#?}"));
@@ -457,7 +495,7 @@ mod helper {
#[cfg_attr(not(bootstrap), define_opaque(Successors))]
pub fn successors_for_value(&self, value: u128) -> Successors<'_> {
let target = self.target_for_value(value);
- (&[]).into_iter().copied().chain(Some(target))
+ (&[]).into_iter().copied().chain(Some(target).into_iter().chain(None))
}
}
@@ -467,13 +505,23 @@ mod helper {
pub fn successors(&self) -> Successors<'_> {
use self::TerminatorKind::*;
match *self {
+ // 3-successors for async drop: target, unwind, dropline (parent coroutine drop)
+ Drop { target: ref t, unwind: UnwindAction::Cleanup(u), drop: Some(d), .. } => {
+ slice::from_ref(t)
+ .into_iter()
+ .copied()
+ .chain(Some(u).into_iter().chain(Some(d)))
+ }
+ // 2-successors
Call { target: Some(ref t), unwind: UnwindAction::Cleanup(u), .. }
| Yield { resume: ref t, drop: Some(u), .. }
- | Drop { target: ref t, unwind: UnwindAction::Cleanup(u), .. }
+ | Drop { target: ref t, unwind: UnwindAction::Cleanup(u), drop: None, .. }
+ | Drop { target: ref t, unwind: _, drop: Some(u), .. }
| Assert { target: ref t, unwind: UnwindAction::Cleanup(u), .. }
| FalseUnwind { real_target: ref t, unwind: UnwindAction::Cleanup(u) } => {
- slice::from_ref(t).into_iter().copied().chain(Some(u))
+ slice::from_ref(t).into_iter().copied().chain(Some(u).into_iter().chain(None))
}
+ // single successor
Goto { target: ref t }
| Call { target: None, unwind: UnwindAction::Cleanup(ref t), .. }
| Call { target: Some(ref t), unwind: _, .. }
@@ -481,23 +529,33 @@ mod helper {
| Drop { target: ref t, unwind: _, .. }
| Assert { target: ref t, unwind: _, .. }
| FalseUnwind { real_target: ref t, unwind: _ } => {
- slice::from_ref(t).into_iter().copied().chain(None)
+ slice::from_ref(t).into_iter().copied().chain(None.into_iter().chain(None))
}
+ // No successors
UnwindResume
| UnwindTerminate(_)
| CoroutineDrop
| Return
| Unreachable
| TailCall { .. }
- | Call { target: None, unwind: _, .. } => (&[]).into_iter().copied().chain(None),
+ | Call { target: None, unwind: _, .. } => {
+ (&[]).into_iter().copied().chain(None.into_iter().chain(None))
+ }
+ // Multiple successors
InlineAsm { ref targets, unwind: UnwindAction::Cleanup(u), .. } => {
- targets.iter().copied().chain(Some(u))
+ targets.iter().copied().chain(Some(u).into_iter().chain(None))
+ }
+ InlineAsm { ref targets, unwind: _, .. } => {
+ targets.iter().copied().chain(None.into_iter().chain(None))
}
- InlineAsm { ref targets, unwind: _, .. } => targets.iter().copied().chain(None),
- SwitchInt { ref targets, .. } => targets.targets.iter().copied().chain(None),
- FalseEdge { ref real_target, imaginary_target } => {
- slice::from_ref(real_target).into_iter().copied().chain(Some(imaginary_target))
+ SwitchInt { ref targets, .. } => {
+ targets.targets.iter().copied().chain(None.into_iter().chain(None))
}
+ // FalseEdge
+ FalseEdge { ref real_target, imaginary_target } => slice::from_ref(real_target)
+ .into_iter()
+ .copied()
+ .chain(Some(imaginary_target).into_iter().chain(None)),
}
}
@@ -506,16 +564,31 @@ mod helper {
pub fn successors_mut(&mut self) -> SuccessorsMut<'_> {
use self::TerminatorKind::*;
match *self {
+ // 3-successors for async drop: target, unwind, dropline (parent coroutine drop)
+ Drop {
+ target: ref mut t,
+ unwind: UnwindAction::Cleanup(ref mut u),
+ drop: Some(ref mut d),
+ ..
+ } => slice::from_mut(t).into_iter().chain(Some(u).into_iter().chain(Some(d))),
+ // 2-successors
Call {
target: Some(ref mut t), unwind: UnwindAction::Cleanup(ref mut u), ..
}
| Yield { resume: ref mut t, drop: Some(ref mut u), .. }
- | Drop { target: ref mut t, unwind: UnwindAction::Cleanup(ref mut u), .. }
+ | Drop {
+ target: ref mut t,
+ unwind: UnwindAction::Cleanup(ref mut u),
+ drop: None,
+ ..
+ }
+ | Drop { target: ref mut t, unwind: _, drop: Some(ref mut u), .. }
| Assert { target: ref mut t, unwind: UnwindAction::Cleanup(ref mut u), .. }
| FalseUnwind {
real_target: ref mut t,
unwind: UnwindAction::Cleanup(ref mut u),
- } => slice::from_mut(t).into_iter().chain(Some(u)),
+ } => slice::from_mut(t).into_iter().chain(Some(u).into_iter().chain(None)),
+ // single successor
Goto { target: ref mut t }
| Call { target: None, unwind: UnwindAction::Cleanup(ref mut t), .. }
| Call { target: Some(ref mut t), unwind: _, .. }
@@ -523,22 +596,33 @@ mod helper {
| Drop { target: ref mut t, unwind: _, .. }
| Assert { target: ref mut t, unwind: _, .. }
| FalseUnwind { real_target: ref mut t, unwind: _ } => {
- slice::from_mut(t).into_iter().chain(None)
+ slice::from_mut(t).into_iter().chain(None.into_iter().chain(None))
}
+ // No successors
UnwindResume
| UnwindTerminate(_)
| CoroutineDrop
| Return
| Unreachable
| TailCall { .. }
- | Call { target: None, unwind: _, .. } => (&mut []).into_iter().chain(None),
+ | Call { target: None, unwind: _, .. } => {
+ (&mut []).into_iter().chain(None.into_iter().chain(None))
+ }
+ // Multiple successors
InlineAsm { ref mut targets, unwind: UnwindAction::Cleanup(ref mut u), .. } => {
- targets.iter_mut().chain(Some(u))
+ targets.iter_mut().chain(Some(u).into_iter().chain(None))
+ }
+ InlineAsm { ref mut targets, unwind: _, .. } => {
+ targets.iter_mut().chain(None.into_iter().chain(None))
+ }
+ SwitchInt { ref mut targets, .. } => {
+ targets.targets.iter_mut().chain(None.into_iter().chain(None))
}
- InlineAsm { ref mut targets, unwind: _, .. } => targets.iter_mut().chain(None),
- SwitchInt { ref mut targets, .. } => targets.targets.iter_mut().chain(None),
+ // FalseEdge
FalseEdge { ref mut real_target, ref mut imaginary_target } => {
- slice::from_mut(real_target).into_iter().chain(Some(imaginary_target))
+ slice::from_mut(real_target)
+ .into_iter()
+ .chain(Some(imaginary_target).into_iter().chain(None))
}
}
}
@@ -671,8 +755,10 @@ impl<'tcx> TerminatorKind<'tcx> {
Goto { target } => TerminatorEdges::Single(target),
+ // FIXME: Maybe we need also TerminatorEdges::Trio for async drop
+ // (target + unwind + dropline)
Assert { target, unwind, expected: _, msg: _, cond: _ }
- | Drop { target, unwind, place: _, replace: _ }
+ | Drop { target, unwind, place: _, replace: _, drop: _, async_fut: _ }
| FalseUnwind { real_target: target, unwind } => match unwind {
UnwindAction::Cleanup(unwind) => TerminatorEdges::Double(target, unwind),
UnwindAction::Continue | UnwindAction::Terminate(_) | UnwindAction::Unreachable => {
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 3c83d962900ae..9ff1ccef2cbf2 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -515,7 +515,14 @@ macro_rules! make_mir_visitor {
self.visit_operand(discr, location);
}
- TerminatorKind::Drop { place, target: _, unwind: _, replace: _ } => {
+ TerminatorKind::Drop {
+ place,
+ target: _,
+ unwind: _,
+ replace: _,
+ drop: _,
+ async_fut: _,
+ } => {
self.visit_place(
place,
PlaceContext::MutatingUse(MutatingUseContext::Drop),
@@ -628,7 +635,7 @@ macro_rules! make_mir_visitor {
OverflowNeg(op) | DivisionByZero(op) | RemainderByZero(op) => {
self.visit_operand(op, location);
}
- ResumedAfterReturn(_) | ResumedAfterPanic(_) | NullPointerDereference => {
+ ResumedAfterReturn(_) | ResumedAfterPanic(_) | NullPointerDereference | ResumedAfterDrop(_) => {
// Nothing to visit
}
MisalignedPointerDereference { required, found } => {
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index 19669021eefb4..59e03fa79a050 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -69,6 +69,8 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
target: self.parse_return_to(args[1])?,
unwind: self.parse_unwind_action(args[2])?,
replace: false,
+ drop: None,
+ async_fut: None,
})
},
@call(mir_call, args) => {
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
index f9791776f71e5..5a97b08db28d6 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -762,6 +762,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
target: success,
unwind: UnwindAction::Continue,
replace: false,
+ drop: None,
+ async_fut: None,
},
);
this.diverge_from(block);
diff --git a/compiler/rustc_mir_build/src/builder/scope.rs b/compiler/rustc_mir_build/src/builder/scope.rs
index e42336a1dbbcc..79225c87d61fd 100644
--- a/compiler/rustc_mir_build/src/builder/scope.rs
+++ b/compiler/rustc_mir_build/src/builder/scope.rs
@@ -405,6 +405,8 @@ impl DropTree {
unwind: UnwindAction::Terminate(UnwindTerminateReason::InCleanup),
place: drop_node.data.local.into(),
replace: false,
+ drop: None,
+ async_fut: None,
};
cfg.terminate(block, drop_node.data.source_info, terminator);
}
@@ -848,6 +850,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
target: next,
unwind: UnwindAction::Continue,
replace: false,
+ drop: None,
+ async_fut: None,
},
);
block = next;
@@ -1371,6 +1375,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
target: assign,
unwind: UnwindAction::Cleanup(assign_unwind),
replace: true,
+ drop: None,
+ async_fut: None,
},
);
self.diverge_from(block);
@@ -1510,6 +1516,8 @@ fn build_scope_drops<'tcx>(
target: next,
unwind: UnwindAction::Continue,
replace: false,
+ drop: None,
+ async_fut: None,
},
);
block = next;
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
index f5ffc42d52ab0..18165b0b9bd08 100644
--- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -376,7 +376,14 @@ impl<'tcx> Analysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
// the result of `is_unwind_dead`.
let mut edges = terminator.edges();
if self.skip_unreachable_unwind
- && let mir::TerminatorKind::Drop { target, unwind, place, replace: _ } = terminator.kind
+ && let mir::TerminatorKind::Drop {
+ target,
+ unwind,
+ place,
+ replace: _,
+ drop: _,
+ async_fut: _,
+ } = terminator.kind
&& matches!(unwind, mir::UnwindAction::Cleanup(_))
&& self.is_unwind_dead(place, state)
{
diff --git a/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs b/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs
index b33326cb873df..a414d120e68b5 100644
--- a/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs
+++ b/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs
@@ -83,7 +83,9 @@ fn add_move_for_packed_drop<'tcx>(
is_cleanup: bool,
) {
debug!("add_move_for_packed_drop({:?} @ {:?})", terminator, loc);
- let TerminatorKind::Drop { ref place, target, unwind, replace } = terminator.kind else {
+ let TerminatorKind::Drop { ref place, target, unwind, replace, drop, async_fut } =
+ terminator.kind
+ else {
unreachable!();
};
@@ -106,6 +108,8 @@ fn add_move_for_packed_drop<'tcx>(
target: storage_dead_block,
unwind,
replace,
+ drop,
+ async_fut,
},
);
}
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index 04d96f117072f..c41c4abec7117 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -1077,7 +1077,8 @@ fn elaborate_coroutine_drops<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let (target, unwind, source_info) = match block_data.terminator() {
Terminator {
source_info,
- kind: TerminatorKind::Drop { place, target, unwind, replace: _ },
+ kind:
+ TerminatorKind::Drop { place, target, unwind, replace: _, drop: _, async_fut: _ },
} => {
if let Some(local) = place.as_local()
&& local == SELF_ARG
@@ -1365,6 +1366,8 @@ fn insert_clean_drop(body: &mut Body<'_>) -> BasicBlock {
target: return_block,
unwind: UnwindAction::Continue,
replace: false,
+ drop: None,
+ async_fut: None,
};
let source_info = SourceInfo::outermost(body.span);
diff --git a/compiler/rustc_mir_transform/src/elaborate_drop.rs b/compiler/rustc_mir_transform/src/elaborate_drop.rs
index 0d8cf524661c8..a824f82d7edce 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drop.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drop.rs
@@ -229,6 +229,8 @@ where
target: self.succ,
unwind: self.unwind.into_action(),
replace: false,
+ drop: None,
+ async_fut: None,
},
);
}
@@ -755,6 +757,8 @@ where
target: loop_block,
unwind: unwind.into_action(),
replace: false,
+ drop: None,
+ async_fut: None,
},
);
@@ -992,6 +996,8 @@ where
target,
unwind: unwind.into_action(),
replace: false,
+ drop: None,
+ async_fut: None,
};
self.new_block(unwind, block)
}
diff --git a/compiler/rustc_mir_transform/src/elaborate_drops.rs b/compiler/rustc_mir_transform/src/elaborate_drops.rs
index 530c72ca549a6..8f11085082fd3 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drops.rs
@@ -328,7 +328,9 @@ impl<'a, 'tcx> ElaborateDropsCtxt<'a, 'tcx> {
// This function should mirror what `collect_drop_flags` does.
for (bb, data) in self.body.basic_blocks.iter_enumerated() {
let terminator = data.terminator();
- let TerminatorKind::Drop { place, target, unwind, replace } = terminator.kind else {
+ let TerminatorKind::Drop { place, target, unwind, replace, drop: _, async_fut: _ } =
+ terminator.kind
+ else {
continue;
};
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 0ab24e48d443c..e2526acc63d28 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -413,7 +413,15 @@ impl<'tcx> Inliner<'tcx> for NormalInliner<'tcx> {
let term = blk.terminator();
let caller_attrs = tcx.codegen_fn_attrs(self.caller_def_id());
- if let TerminatorKind::Drop { ref place, target, unwind, replace: _ } = term.kind {
+ if let TerminatorKind::Drop {
+ ref place,
+ target,
+ unwind,
+ replace: _,
+ drop: _,
+ async_fut: _,
+ } = term.kind
+ {
work_list.push(target);
// If the place doesn't actually need dropping, treat it like a regular goto.
diff --git a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
index 29a9133abe93d..496335ee3c12f 100644
--- a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
+++ b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
@@ -134,6 +134,8 @@ impl<'a, 'mir, 'tcx> DropsReachable<'a, 'mir, 'tcx> {
target: _,
unwind: _,
replace: _,
+ drop: _,
+ async_fut: _,
} = &terminator.kind
&& place_has_common_prefix(dropped_place, self.place)
{
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index c9771467e499c..70a7265980986 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -621,6 +621,8 @@ impl<'tcx> CloneShimBuilder<'tcx> {
target: unwind,
unwind: UnwindAction::Terminate(UnwindTerminateReason::InCleanup),
replace: false,
+ drop: None,
+ async_fut: None,
},
/* is_cleanup */ true,
);
@@ -886,6 +888,8 @@ fn build_call_shim<'tcx>(
target: BasicBlock::new(2),
unwind: UnwindAction::Continue,
replace: false,
+ drop: None,
+ async_fut: None,
},
false,
);
@@ -903,6 +907,8 @@ fn build_call_shim<'tcx>(
target: BasicBlock::new(4),
unwind: UnwindAction::Terminate(UnwindTerminateReason::InCleanup),
replace: false,
+ drop: None,
+ async_fut: None,
},
/* is_cleanup */ true,
);
diff --git a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
index 94b1b4b1855b5..e7ef8bf5489c2 100644
--- a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
+++ b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
@@ -424,6 +424,8 @@ impl<'tcx> AsyncDestructorCtorShimBuilder<'tcx> {
UnwindTerminateReason::InCleanup,
),
replace: false,
+ drop: None,
+ async_fut: None,
}
} else {
TerminatorKind::Goto { target: *top_cleanup_bb }
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index e7930f0a1e3f6..4647839b95c2a 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -373,9 +373,12 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
);
}
}
- TerminatorKind::Drop { target, unwind, .. } => {
+ TerminatorKind::Drop { target, unwind, drop, .. } => {
self.check_edge(location, *target, EdgeKind::Normal);
self.check_unwind_edge(location, *unwind);
+ if let Some(drop) = drop {
+ self.check_edge(location, *drop, EdgeKind::Normal);
+ }
}
TerminatorKind::Call { func, args, .. }
| TerminatorKind::TailCall { func, args, .. } => {
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
index 61b769bce0831..42b3e59b73ab9 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
@@ -494,6 +494,9 @@ impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> {
AssertKind::ResumedAfterPanic(coroutine) => {
stable_mir::mir::AssertMessage::ResumedAfterPanic(coroutine.stable(tables))
}
+ AssertKind::ResumedAfterDrop(coroutine) => {
+ stable_mir::mir::AssertMessage::ResumedAfterDrop(coroutine.stable(tables))
+ }
AssertKind::MisalignedPointerDereference { required, found } => {
stable_mir::mir::AssertMessage::MisalignedPointerDereference {
required: required.stable(tables),
@@ -648,13 +651,18 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> {
mir::TerminatorKind::UnwindTerminate(_) => TerminatorKind::Abort,
mir::TerminatorKind::Return => TerminatorKind::Return,
mir::TerminatorKind::Unreachable => TerminatorKind::Unreachable,
- mir::TerminatorKind::Drop { place, target, unwind, replace: _ } => {
- TerminatorKind::Drop {
- place: place.stable(tables),
- target: target.as_usize(),
- unwind: unwind.stable(tables),
- }
- }
+ mir::TerminatorKind::Drop {
+ place,
+ target,
+ unwind,
+ replace: _,
+ drop: _,
+ async_fut: _,
+ } => TerminatorKind::Drop {
+ place: place.stable(tables),
+ target: target.as_usize(),
+ unwind: unwind.stable(tables),
+ },
mir::TerminatorKind::Call {
func,
args,
diff --git a/compiler/rustc_smir/src/stable_mir/mir/body.rs b/compiler/rustc_smir/src/stable_mir/mir/body.rs
index b23605454246e..660cd7db0800d 100644
--- a/compiler/rustc_smir/src/stable_mir/mir/body.rs
+++ b/compiler/rustc_smir/src/stable_mir/mir/body.rs
@@ -267,6 +267,7 @@ pub enum AssertMessage {
RemainderByZero(Operand),
ResumedAfterReturn(CoroutineKind),
ResumedAfterPanic(CoroutineKind),
+ ResumedAfterDrop(CoroutineKind),
MisalignedPointerDereference { required: Operand, found: Operand },
NullPointerDereference,
}
@@ -320,6 +321,22 @@ impl AssertMessage {
_,
)) => Ok("`gen fn` should just keep returning `AssertMessage::None` after panicking"),
+ AssertMessage::ResumedAfterDrop(CoroutineKind::Coroutine(_)) => {
+ Ok("coroutine resumed after async drop")
+ }
+ AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
+ CoroutineDesugaring::Async,
+ _,
+ )) => Ok("`async fn` resumed after async drop"),
+ AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
+ CoroutineDesugaring::Gen,
+ _,
+ )) => Ok("`async gen fn` resumed after async drop"),
+ AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
+ CoroutineDesugaring::AsyncGen,
+ _,
+ )) => Ok("`gen fn` should just keep returning `AssertMessage::None` after async drop"),
+
AssertMessage::BoundsCheck { .. } => Ok("index out of bounds"),
AssertMessage::MisalignedPointerDereference { .. } => {
Ok("misaligned pointer dereference")
diff --git a/compiler/rustc_smir/src/stable_mir/mir/pretty.rs b/compiler/rustc_smir/src/stable_mir/mir/pretty.rs
index 439ebe978e591..7b96add854ad0 100644
--- a/compiler/rustc_smir/src/stable_mir/mir/pretty.rs
+++ b/compiler/rustc_smir/src/stable_mir/mir/pretty.rs
@@ -312,7 +312,9 @@ fn pretty_assert_message<W: Write>(writer: &mut W, msg: &AssertMessage) -> io::R
AssertMessage::NullPointerDereference => {
write!(writer, "\"null pointer dereference occurred\"")
}
- AssertMessage::ResumedAfterReturn(_) | AssertMessage::ResumedAfterPanic(_) => {
+ AssertMessage::ResumedAfterReturn(_)
+ | AssertMessage::ResumedAfterPanic(_)
+ | AssertMessage::ResumedAfterDrop(_) => {
write!(writer, "{}", msg.description().unwrap())
}
}
diff --git a/compiler/rustc_smir/src/stable_mir/mir/visit.rs b/compiler/rustc_smir/src/stable_mir/mir/visit.rs
index 786693ea98d36..e21dc11eea9ca 100644
--- a/compiler/rustc_smir/src/stable_mir/mir/visit.rs
+++ b/compiler/rustc_smir/src/stable_mir/mir/visit.rs
@@ -372,7 +372,8 @@ macro_rules! make_mir_visitor {
}
AssertMessage::ResumedAfterReturn(_)
| AssertMessage::ResumedAfterPanic(_)
- | AssertMessage::NullPointerDereference => {
+ | AssertMessage::NullPointerDereference
+ | AssertMessage::ResumedAfterDrop(_) => {
//nothing to visit
}
AssertMessage::MisalignedPointerDereference { required, found } => {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 31847ae3b4658..7bd0989f5fa14 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1518,14 +1518,18 @@ symbols! {
panic_cannot_unwind,
panic_const_add_overflow,
panic_const_async_fn_resumed,
+ panic_const_async_fn_resumed_drop,
panic_const_async_fn_resumed_panic,
panic_const_async_gen_fn_resumed,
+ panic_const_async_gen_fn_resumed_drop,
panic_const_async_gen_fn_resumed_panic,
panic_const_coroutine_resumed,
+ panic_const_coroutine_resumed_drop,
panic_const_coroutine_resumed_panic,
panic_const_div_by_zero,
panic_const_div_overflow,
panic_const_gen_fn_none,
+ panic_const_gen_fn_none_drop,
panic_const_gen_fn_none_panic,
panic_const_mul_overflow,
panic_const_neg_overflow,
diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs
index 33ad59916e391..83a45436b3050 100644
--- a/library/core/src/panicking.rs
+++ b/library/core/src/panicking.rs
@@ -155,30 +155,26 @@ pub const fn panic(expr: &'static str) -> ! {
// reducing binary size impact.
macro_rules! panic_const {
($($lang:ident = $message:expr,)+) => {
- pub mod panic_const {
- use super::*;
-
- $(
- /// This is a panic called with a message that's a result of a MIR-produced Assert.
- //
- // never inline unless panic_immediate_abort to avoid code
- // bloat at the call sites as much as possible
- #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
- #[cfg_attr(feature = "panic_immediate_abort", inline)]
- #[track_caller]
- #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
- #[lang = stringify!($lang)]
- pub const fn $lang() -> ! {
- // Use Arguments::new_const instead of format_args!("{expr}") to potentially
- // reduce size overhead. The format_args! macro uses str's Display trait to
- // write expr, which calls Formatter::pad, which must accommodate string
- // truncation and padding (even though none is used here). Using
- // Arguments::new_const may allow the compiler to omit Formatter::pad from the
- // output binary, saving up to a few kilobytes.
- panic_fmt(fmt::Arguments::new_const(&[$message]));
- }
- )+
- }
+ $(
+ /// This is a panic called with a message that's a result of a MIR-produced Assert.
+ //
+ // never inline unless panic_immediate_abort to avoid code
+ // bloat at the call sites as much as possible
+ #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
+ #[cfg_attr(feature = "panic_immediate_abort", inline)]
+ #[track_caller]
+ #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
+ #[lang = stringify!($lang)]
+ pub const fn $lang() -> ! {
+ // Use Arguments::new_const instead of format_args!("{expr}") to potentially
+ // reduce size overhead. The format_args! macro uses str's Display trait to
+ // write expr, which calls Formatter::pad, which must accommodate string
+ // truncation and padding (even though none is used here). Using
+ // Arguments::new_const may allow the compiler to omit Formatter::pad from the
+ // output binary, saving up to a few kilobytes.
+ panic_fmt(fmt::Arguments::new_const(&[$message]));
+ }
+ )+
}
}
@@ -186,25 +182,37 @@ macro_rules! panic_const {
// slightly different forms. It's not clear if there's a good way to deduplicate without adding
// special cases to the compiler (e.g., a const generic function wouldn't have a single definition
// shared across crates, which is exactly what we want here).
-panic_const! {
- panic_const_add_overflow = "attempt to add with overflow",
- panic_const_sub_overflow = "attempt to subtract with overflow",
- panic_const_mul_overflow = "attempt to multiply with overflow",
- panic_const_div_overflow = "attempt to divide with overflow",
- panic_const_rem_overflow = "attempt to calculate the remainder with overflow",
- panic_const_neg_overflow = "attempt to negate with overflow",
- panic_const_shr_overflow = "attempt to shift right with overflow",
- panic_const_shl_overflow = "attempt to shift left with overflow",
- panic_const_div_by_zero = "attempt to divide by zero",
- panic_const_rem_by_zero = "attempt to calculate the remainder with a divisor of zero",
- panic_const_coroutine_resumed = "coroutine resumed after completion",
- panic_const_async_fn_resumed = "`async fn` resumed after completion",
- panic_const_async_gen_fn_resumed = "`async gen fn` resumed after completion",
- panic_const_gen_fn_none = "`gen fn` should just keep returning `None` after completion",
- panic_const_coroutine_resumed_panic = "coroutine resumed after panicking",
- panic_const_async_fn_resumed_panic = "`async fn` resumed after panicking",
- panic_const_async_gen_fn_resumed_panic = "`async gen fn` resumed after panicking",
- panic_const_gen_fn_none_panic = "`gen fn` should just keep returning `None` after panicking",
+pub mod panic_const {
+ use super::*;
+ panic_const! {
+ panic_const_add_overflow = "attempt to add with overflow",
+ panic_const_sub_overflow = "attempt to subtract with overflow",
+ panic_const_mul_overflow = "attempt to multiply with overflow",
+ panic_const_div_overflow = "attempt to divide with overflow",
+ panic_const_rem_overflow = "attempt to calculate the remainder with overflow",
+ panic_const_neg_overflow = "attempt to negate with overflow",
+ panic_const_shr_overflow = "attempt to shift right with overflow",
+ panic_const_shl_overflow = "attempt to shift left with overflow",
+ panic_const_div_by_zero = "attempt to divide by zero",
+ panic_const_rem_by_zero = "attempt to calculate the remainder with a divisor of zero",
+ panic_const_coroutine_resumed = "coroutine resumed after completion",
+ panic_const_async_fn_resumed = "`async fn` resumed after completion",
+ panic_const_async_gen_fn_resumed = "`async gen fn` resumed after completion",
+ panic_const_gen_fn_none = "`gen fn` should just keep returning `None` after completion",
+ panic_const_coroutine_resumed_panic = "coroutine resumed after panicking",
+ panic_const_async_fn_resumed_panic = "`async fn` resumed after panicking",
+ panic_const_async_gen_fn_resumed_panic = "`async gen fn` resumed after panicking",
+ panic_const_gen_fn_none_panic = "`gen fn` should just keep returning `None` after panicking",
+ }
+ // Separated panic constants list for async drop feature
+ // (May be joined when the corresponding lang items will be in the bootstrap)
+ #[cfg(not(bootstrap))]
+ panic_const! {
+ panic_const_coroutine_resumed_drop = "coroutine resumed after async drop",
+ panic_const_async_fn_resumed_drop = "`async fn` resumed after async drop",
+ panic_const_async_gen_fn_resumed_drop = "`async gen fn` resumed after async drop",
+ panic_const_gen_fn_none_drop = "`gen fn` resumed after async drop",
+ }
}
/// Like `panic`, but without unwinding and track_caller to reduce the impact on codesize on the caller.