What's the panic policy for dropping future and output?

[3andero]

While it's clear that tokio will catch panics on polls, it has different policies for panics on drops.
For example:
If panic happens during the drop after completion, tokio will catch and ignore it:

tokio/tokio/src/runtime/task/harness.rs

Lines 292 to 298 in 4eed411

	let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| {
	if !snapshot.is_join_interested() {
	// The `JoinHandle` is not interested in the output of
	// this task. It is our responsibility to drop the
	// output.
	self.core().stage.drop_future_or_output();
	} else if snapshot.has_join_waker() {

If panic happens during dropping the handle, tokio won't ignore it:

tokio/tokio/src/runtime/task/harness.rs

Lines 190 to 192 in 4eed411

	if let Some(panic) = maybe_panic {
	panic::resume_unwind(panic);
	}

If panic happens during cancellation, tokio will catch it:

tokio/tokio/src/runtime/task/harness.rs

Lines 431 to 433 in 4eed411

	let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
	stage.drop_future_or_output();
	}));

If panic happens after a panic during polling, tokio won't catch it and thus causes a double panic:

tokio/tokio/src/runtime/task/harness.rs

Lines 453 to 459 in 4eed411

	impl<'a, T: Future> Drop for Guard<'a, T> {
	fn drop(&mut self) {
	// If the future panics on poll, we drop it inside the panic
	// guard.
	self.core.drop_future_or_output();
	}
	}

Should we have a consistent policy for panics?

[Darksonn]

One of these is a bug, which I filed here: #4412. The rest are consistent behavior — the panic is passed on to the JoinHandle and the user can retrieve it by polling the JoinHandle. If the JoinHandle is dropped, then the panic is lost. (The panic handler will still print it to stdout.)

[3andero]

Make sense except for the last case though. Don't we need to catch possible panic here?

tokio/tokio/src/runtime/task/harness.rs

Lines 453 to 459 in 4eed411

	impl<'a, T: Future> Drop for Guard<'a, T> {
	fn drop(&mut self) {
	// If the future panics on poll, we drop it inside the panic
	// guard.
	self.core.drop_future_or_output();
	}
	}

It seems the potential double panic will crash the whole runtime regardless of whether you're holding a JoinHandle.

[Darksonn]

Ah, well, I do think this one makes sense. If you panic, then all local variables are dropped, and the future behaves like a local variable in this case. A panic in the destructor of a local variable is a double panic.

[3andero]

Now I understand this is a feature. Thank you for your explanation. 😊