`future_to_promise` Promise is not rejected if rust panics asynchronously

[mstange]

Describe the Bug

From the future_to_promise documentation:

If the future provided panics then the returned Promise will not resolve. Instead it will be a leaked promise. This is an unfortunate limitation of wasm currently that’s hoped to be fixed one day!

This behavior is very undesirable, so I think it would be good to have a bug on file for it.

I'm also curious about what the exact wasm limitation is, and where I can follow plans to fix it.

Steps to Reproduce

Rust:

use js_sys::Promise;
use wasm_bindgen::prelude::*;
use wasm_bindgen_futures::{future_to_promise, JsFuture};

#[wasm_bindgen]
pub fn mywasmfun() -> Promise {
    future_to_promise(mywasmfun_impl())
}

async fn mywasmfun_impl() -> Result<JsValue, JsValue> {
    panic!("Please catch this panic");
}

JS:

import init, { mywasmfun } from './pkg/wasm_bindgen_async_panic.js';

async function run() {
  await init();

  try {
    await mywasmfun();
  } catch (e) {
    console.log("Caught exception:", e);
  }
}

run();

Expected Behavior

Panics should be propagated upwards the "async stack" so that any awaits on the JS side can catch panics and don't keep waiting forever.

Actual Behavior

The panic never propagates, the await never completes.

[mstange]

So, from what I understand, the promise can only reject if something calls its reject handler. Usually this handler would be called from the Rust code. But since the Rust code has panicked, there's no one to call reject.

Might there be a way to make the JS-side of the bindings smarter, so that it can catch the panic exception and call reject without help from the Rust side?

[alexcrichton]

Thanks for the report, but panics unfortunately basically don't work as means of communicating errors. Given the lack of exception handling in wasm handling panics is extremely difficult right now and largely not done by wasm-bindgen, leading to issues such as this. This is unlikely to change in the near future unfortuantely.

[xtuc]

@alexcrichton do you see a way to do error handling with rewriting the binary? Could the unreachable instruction be replaced by a wasm-bindgen call that would end up rejecting the Promise?

[temeddix]

@xtuc Thank you for investigating this problem. May I ask, does that commit you made fixes this issue?

[daxpedda]

I'm going to close this as not really actionable.
The solution is to implement the exception handling proposal in Rust, until then panic! aren't supported and are more or less unsound. See #3687.