proc_macro2::TokenStream doesn't implement UnwindSafe

[hniksic]

While writing tests for a procedural macro I learned that proc_macro2::TokenStream isn't UnwindSafe. Since I suspect it is not intentional, I am reporting it here.

In my tests I have a function that executes a thunk and asserts that it panicked, something like this:

fn assert_panic(f: impl FnOnce() + std::panic::UnwindSafe) {
    if std::panic::catch_unwind(f).is_ok() {
        panic!("panic didn't happen");
    }
    // in real code this also asserts that the panic that occurred matches an
    // expected message substring
}

I'd like to test my proc macro with a range of inputs that should all fail, as in this test:

fn macro_impl(input: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
    todo!()
}

fn main() {
    for unsupported_type in &[quote!(i8), quote!(u128), quote!(())] {
        assert_panic(|| {
            macro_impl(quote! {
                struct X {
                    field: #unsupported_type
                }
            });
        });
    }
}

But the above code fails to compile with the following error (playground):

error[E0277]: the type `std::cell::UnsafeCell<usize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
  --> src/main.rs:18:9
   |
4  | fn assert_panic(f: impl FnOnce() + std::panic::UnwindSafe) {
   |                                    ---------------------- required by this bound in `assert_panic`
...
18 |         assert_panic(|| {
   |         ^^^^^^^^^^^^ `std::cell::UnsafeCell<usize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
   |
   = help: within `&proc_macro2::TokenStream`, the trait `std::panic::RefUnwindSafe` is not implemented for `std::cell::UnsafeCell<usize>`
   = note: required because it appears within the type `std::cell::Cell<usize>`
   = note: required because it appears within the type `std::rc::RcBox<()>`
   = note: required because it appears within the type `std::marker::PhantomData<std::rc::RcBox<()>>`
   = note: required because it appears within the type `std::rc::Rc<()>`
   = note: required because it appears within the type `std::marker::PhantomData<std::rc::Rc<()>>`
   = note: required because it appears within the type `proc_macro2::TokenStream`
   = note: required because it appears within the type `&proc_macro2::TokenStream`
   = note: required because of the requirements on the impl of `std::panic::UnwindSafe` for `&&proc_macro2::TokenStream`
   = note: required because it appears within the type `[closure@src/main.rs:18:22: 24:10 unsupported_type:&&proc_macro2::TokenStream]`

I don't know if this is intentional, but I suspect it might not be. Perhaps UnsafeCell is used for efficiency and the type is actually UnwindSafe, it just needs the appropriate explicit marker.

I worked around the issue by avoiding the capture of TokenStreams produced by quote! and capturing strings instead (playground):

fn main() {
    for unsupported_type in &["i8", "u128", "()"] {
        assert_panic(|| {
            let unsupported_type: proc_macro2::TokenStream = syn::parse_str(unsupported_type).unwrap();
            macro_impl(quote! {
                struct X {
                    field: #unsupported_type
                }
            });
        });
    }
}

That works, but the explicit parsing is less readable than quote!. If TokenStream can be UnwindSafe, it would be nice for it to implement the trait.

[dtolnay]

Fixed in 1.0.21.