How to correctly call Dart functions from Rust?

[xiaohucode]

Help me, thank you very much!

When generating the http_get function, an error will be reported in the frb_generated.rs file.

Running cargo check will get the error

cargo check:

PS E:\soursce\flutter\yida\rust> cargo check
    Checking rust_lib v0.1.0 (E:\soursce\flutter\yida\rust)
error[E0277]: the type `&mut impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` may not be safely transferred across an unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |       FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                   ^^^^^^^^^^ `&mut impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` may not be safely transferred across an unwind boundary
...
58 |               move |context| async move {
   |  ____________________________-
59 | |                 transform_result_dco(
60 | |                     (move || async move {
61 | |                         Result::<_, ()>::Ok(
...  |
73 | |                 )
74 | |             }
   | |_____________- within this `{async block@src\frb_generated.rs:58:28: 74:14}`
   |
   = help: within `{async block@src\frb_generated.rs:58:28: 74:14}`, the trait `UnwindSafe` is not implemented for `&mut impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>`
note: future does not implement `UnwindSafe` as it awaits another future which does not implement `UnwindSafe`
  --> src\api\http.rs:42:32
   |
42 |         while let Some(item) = stream.next().await {
   |                                ^^^^^^^^^^^^^ await occurs here on type `Next<'_, impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>>`, which does not implement `UnwindSafe`
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn CookieStore + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn CookieStore + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `reqwest::async_impl::client::ClientRef`, the trait `RefUnwindSafe` is not implemented for `(dyn CookieStore + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:40:51
   |
28 |     let client = builder
   |         ------ has type `reqwest::Client` which does not implement `UnwindSafe`
...
40 |         response_callback(status_code.into(), id).await;
   |                                                   ^^^^^ await occurs here, with `client` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn for<'a> Fn(Attempt<'a>) -> reqwest::redirect::Action + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn for<'a> Fn(Attempt<'a>) -> reqwest::redirect::Action + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `reqwest::async_impl::client::ClientRef`, the trait `RefUnwindSafe` is not implemented for `(dyn for<'a> Fn(Attempt<'a>) -> reqwest::redirect::Action + std::marker::Send + std::marker::Sync + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:40:51
   |
28 |     let client = builder
   |         ------ has type `reqwest::Client` which does not implement `UnwindSafe`
...
40 |         response_callback(status_code.into(), id).await;
   |                                                   ^^^^^ await occurs here, with `client` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn std::error::Error + std::marker::Send + std::marker::Sync + 'static)` may not be safely transferred across an unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn std::error::Error + std::marker::Send + std::marker::Sync + 'static)` may not be safely transferred across an unwind boundary
   |
   = help: the trait `UnwindSafe` is not implemented for `(dyn std::error::Error + std::marker::Send + std::marker::Sync + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:40:51
   |
37 |     let response = block_on(async { request.send().await });
   |         -------- has type `Result<reqwest::Response, reqwest::Error>` which does not implement `UnwindSafe`
...
40 |         response_callback(status_code.into(), id).await;
   |                                                   ^^^^^ await occurs here, with `response` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn hyper::rt::Executor<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>> + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn hyper::rt::Executor<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>> + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `reqwest::async_impl::client::ClientRef`, the trait `RefUnwindSafe` is not implemented for `(dyn hyper::rt::Executor<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>> + std::marker::Send + std::marker::Sync + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:40:51
   |
28 |     let client = builder
   |         ------ has type `reqwest::Client` which does not implement `UnwindSafe`
...
40 |         response_callback(status_code.into(), id).await;
   |                                                   ^^^^^ await occurs here, with `client` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn http_body::Body<Data = bytes::bytes::Bytes, Error = Box<(dyn std::error::Error + std::marker::Send + std::marker::Sync + 'static)>> + std::marker::Send + std::marker::Sync + 'static)` may not be safely transferred across an unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn http_body::Body<Data = bytes::bytes::Bytes, Error = Box<(dyn std::error::Error + std::marker::Send + std::marker::Sync + 'static)>> + std::marker::Send + std::marker::Sync + 'static)` may not be safely transferred across an unwind boundary
   |
   = help: the trait `UnwindSafe` is not implemented for `(dyn http_body::Body<Data = bytes::bytes::Bytes, Error = Box<(dyn std::error::Error + std::marker::Send + std::marker::Sync + 'static)>> + std::marker::Send + std::marker::Sync + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn std::any::Any + std::marker::Send + std::marker::Sync + 'static)` may not be safely transferred across an unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn std::any::Any + std::marker::Send + std::marker::Sync + 'static)` may not be safely transferred across an unwind boundary   
   |
   = help: the trait `UnwindSafe` is not implemented for `(dyn std::any::Any + std::marker::Send + std::marker::Sync + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:40:51
   |
38 |     if let Ok(response) = response {
   |               -------- has type `reqwest::Response` which does not implement `UnwindSafe`
39 |         let status_code = response.status().as_u16();
40 |         response_callback(status_code.into(), id).await;
   |                                                   ^^^^^ await occurs here, with `response` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn Resolve + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn Resolve + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `reqwest::async_impl::client::ClientRef`, the trait `RefUnwindSafe` is not implemented for `(dyn Resolve + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:40:51
   |
28 |     let client = builder
   |         ------ has type `reqwest::Client` which does not implement `UnwindSafe`
...
40 |         response_callback(status_code.into(), id).await;
   |                                                   ^^^^^ await occurs here, with `client` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn for<'a> Fn(&'a Url) -> Option<Result<reqwest::proxy::ProxyScheme, reqwest::Error>> + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn for<'a> Fn(&'a Url) -> Option<Result<reqwest::proxy::ProxyScheme, reqwest::Error>> + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `reqwest::async_impl::client::ClientRef`, the trait `RefUnwindSafe` is not implemented for `(dyn for<'a> Fn(&'a Url) -> Option<Result<reqwest::proxy::ProxyScheme, reqwest::Error>> + std::marker::Send + std::marker::Sync + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:40:51
   |
28 |     let client = builder
   |         ------ has type `reqwest::Client` which does not implement `UnwindSafe`
...
40 |         response_callback(status_code.into(), id).await;
   |                                                   ^^^^^ await occurs here, with `client` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<AtomicUsize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<AtomicUsize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::multi_thread::handle::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<AtomicUsize>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<runtime::scheduler::multi_thread::worker::Synced>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<runtime::scheduler::multi_thread::worker::Synced>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::multi_thread::handle::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<runtime::scheduler::multi_thread::worker::Synced>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<Vec<Box<runtime::scheduler::multi_thread::worker::Core>>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<Vec<Box<runtime::scheduler::multi_thread::worker::Core>>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::multi_thread::handle::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<Vec<Box<runtime::scheduler::multi_thread::worker::Core>>>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<runtime::scheduler::inject::synced::Synced>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<runtime::scheduler::inject::synced::Synced>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<runtime::scheduler::inject::synced::Synced>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<runtime::io::registration_set::Synced>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<runtime::io::registration_set::Synced>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<runtime::io::registration_set::Synced>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn Fn() + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn Fn() + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `(dyn Fn() + std::marker::Send + std::marker::Sync + 'static)`   
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<runtime::time::InnerState>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary     
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<runtime::time::InnerState>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<runtime::time::InnerState>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<tokio::util::linked_list::PointersInner<runtime::time::entry::TimerShared>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<tokio::util::linked_list::PointersInner<runtime::time::entry::TimerShared>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::time::entry::TimerShared`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<tokio::util::linked_list::PointersInner<runtime::time::entry::TimerShared>>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<runtime::blocking::pool::Shared>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<runtime::blocking::pool::Shared>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<runtime::blocking::pool::Shared>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<Result<(), tokio::time::error::Error>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<Result<(), tokio::time::error::Error>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::time::entry::TimerShared`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<Result<(), tokio::time::error::Error>>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `(dyn Fn() -> String + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `(dyn Fn() -> String + std::marker::Send + std::marker::Sync + 'static)` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `(dyn Fn() -> String + std::marker::Send + std::marker::Sync + 'static)`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<tokio::util::linked_list::LinkedList<runtime::task::Task<Arc<runtime::scheduler::current_thread::Handle>>, runtime::task::core::Header>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<tokio::util::linked_list::LinkedList<runtime::task::Task<Arc<runtime::scheduler::current_thread::Handle>>, runtime::task::core::Header>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<tokio::util::linked_list::LinkedList<runtime::task::Task<Arc<runtime::scheduler::current_thread::Handle>>, runtime::task::core::Header>>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary   
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<()>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<std::sys::windows::c::windows_sys::CONDITION_VARIABLE>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<std::sys::windows::c::windows_sys::CONDITION_VARIABLE>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::current_thread::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<std::sys::windows::c::windows_sys::CONDITION_VARIABLE>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<tokio::util::linked_list::LinkedList<runtime::task::Task<Arc<runtime::scheduler::multi_thread::handle::Handle>>, runtime::task::core::Header>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<tokio::util::linked_list::LinkedList<runtime::task::Task<Arc<runtime::scheduler::multi_thread::handle::Handle>>, runtime::task::core::Header>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::multi_thread::handle::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<tokio::util::linked_list::LinkedList<runtime::task::Task<Arc<runtime::scheduler::multi_thread::handle::Handle>>, runtime::task::core::Header>>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<AtomicU32>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<AtomicU32>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::multi_thread::handle::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<AtomicU32>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<MaybeUninit<runtime::task::Notified<Arc<runtime::scheduler::multi_thread::handle::Handle>>>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<MaybeUninit<runtime::task::Notified<Arc<runtime::scheduler::multi_thread::handle::Handle>>>>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::multi_thread::handle::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<MaybeUninit<runtime::task::Notified<Arc<runtime::scheduler::multi_thread::handle::Handle>>>>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

error[E0277]: the type `UnsafeCell<runtime::driver::Driver>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary       
  --> src\frb_generated.rs:43:33
   |
43 |     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
   |                                 ^^^^^^^^^^ `UnsafeCell<runtime::driver::Driver>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `runtime::scheduler::multi_thread::handle::Handle`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<runtime::driver::Driver>`
note: future does not implement `UnwindSafe` as this value is used across an await
  --> src\api\http.rs:42:46
   |
41 |         let mut stream = response.bytes_stream();
   |             ---------- has type `impl futures::Stream<Item = Result<bytes::bytes::Bytes, reqwest::Error>>` which does not implement `UnwindSafe`
42 |         while let Some(item) = stream.next().await {
   |                                              ^^^^^ await occurs here, with `mut stream` maybe used later
note: required by a bound in `wrap_async`
  --> C:\Users\xcode\.cargo\registry\src\index.crates.io-6f17d22bba15001f\flutter_rust_bridge-2.0.0-dev.3\src\handler\handler.rs:64:15
   |
55 |     fn wrap_async<Rust2DartCodec, PrepareFn, TaskFn, TaskRetFut>(
   |        ---------- required by a bound in this associated function
...
64 |             + UnwindSafe,
   |               ^^^^^^^^^^ required by this bound in `Handler::wrap_async`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `rust_lib` (lib) due to 27 previous errors

http_simple.rs

use std::panic::UnwindSafe;

use crate::block_on;
use flutter_rust_bridge::DartFnFuture;
use futures::StreamExt;
use reqwest;

#[derive(Debug)]
pub struct RustHttpHeader {
    pub key: String,
    pub value: String,
}

#[derive(Debug)]
pub struct RustResponse {
    pub status_code: i32,
    pub http_headers: Vec<RustHttpHeader>,
}

pub async fn http_get(
    url: String,
    id: i32,
    data_callback: impl Fn(Vec<u8>, i32) -> DartFnFuture<String> + UnwindSafe,
    response_callback: impl Fn(i32, i32) -> DartFnFuture<String> + UnwindSafe,
    complete_callback: impl Fn(i32) -> DartFnFuture<()> + UnwindSafe,
) {
    let builder = reqwest::ClientBuilder::new();
    let client = builder
        .gzip(true)
        .danger_accept_invalid_certs(true)
        .cookie_store(true)
        .use_native_tls()
        .build()
        .expect("msg");
    let request = client.request(reqwest::Method::GET, url);

    let response = block_on(async { request.send().await });
    if let Ok(response) = response {
        let status_code = response.status().as_u16();
        response_callback(status_code.into(), id).await;
        let mut stream = response.bytes_stream();
        while let Some(item) = stream.next().await {
            if let Ok(bytes) = item {
                data_callback(bytes.to_vec(), id).await;
            }
        }
    }
    complete_callback(id.to_owned()).await;
}

[fzyzcjy]

Hmm, looks like your code is not UnwindSafe. Maybe:

1. Use AssertUnwindSafe everywhere to tell compiler, even if it may be not unwindsafe, you do not care and is happy (I personally do not care in my app, but leave this to the users since I do not know whether the users care)
2. Or, make a PR to automatically generate AssertUnwindSafe, such that you do not need to manually wrap with AssertUnwindSafe. (If someone really wants the compiler hint of unwind-not-safe, maybe we can additionally add a flag for this behavior; but that is another story)

[xiaohucode]

Thank!

[fzyzcjy]

You are welcome!